 Grocery stores already keep track of their inventory but often do not utilize this information to make better informed decisions to improve their stores.
Grocery Analytics aims to solve this problem. By utilizing the data that grocery stores collect, like store traffic and inventory sold, Grocery Analytics helps grocery store owners and employees to make decisions for their business that's backed by data.
Home Screen
Item Analytics Screen
Store Traffic Screen - Hourly
Store Traffic Screen - Weekly
Store Traffic Screen - Monthly
Store Analytics Screen
Clone the project
Option 1: Use Command Line or Terminal to clone project into desired folder
Option 2: Go to https://github.com/JaniceLu/cmpe172_project and click on "Clone or download"
git clone https://github.com/JaniceLu/cmpe172_project.git
Run the client on localhost
All parts of this project are free to use under the open-source MIT license.


Class that holds and handles a CodeBlock
's SnapCollider
s.
More...
Class that holds and handles a CodeBlock
's SnapCollider
s.
It is mainly used to turn this CodeBlock
's SnapCollider
s on and off when the user grabs a the CodeBlock
or lets it go.
◆ DisableAllCollidersAndChildrenColliders()
| void MoveToCode.SnapColliderGroup.DisableAllCollidersAndChildrenColliders |
( |
| ) |
|
Disables this CodeBlock's SnapColliders and recurssively does the tree of snap colliders
◆ EnableAllCollidersAndChildrenColliders()
| void MoveToCode.SnapColliderGroup.EnableAllCollidersAndChildrenColliders |
( |
| ) |
|
Enables this CodeBlock's SnapColliders and recurssively does the tree of snap colliders
◆ RegisterSnapCollider()
| void MoveToCode.SnapColliderGroup.RegisterSnapCollider |
( |
KeyValuePair< Type, int > |
scKeyType, |
|
|
SnapCollider |
snapCollider |
|
) |
| |
Registers the SnapCollider
of this CodeBlock
to be enabled/disabled when MyCodeBlock
is grabbed.
- Parameters
-
◆ MyCodeBlock
| CodeBlock MoveToCode.SnapColliderGroup.MyCodeBlock |
|
get |
◆ SnapColliderSet
| Dictionary<KeyValuePair<Type, int>, SnapCollider> MoveToCode.SnapColliderGroup.SnapColliderSet = new Dictionary<KeyValuePair<Type, int>, SnapCollider>() |
|
getset |
The documentation for this class was generated from the following file:


--- layout: post status: publish published: true title: Wrigley Field Renovation with Danny Rockett - Podcast Episode 6.42 author: display_name: Corey Fineran login: Corey email<EMAIL_ADDRESS>url: '' author_login: Corey author_email<EMAIL_ADDRESS>wordpress_id: 10451 wordpress_url: http://ivyenvy.com/?p=10451 date: '2014-10-26 20:00:25 +0000' date_gmt: '2014-10-27 01:00:25 +0000' categories: - Wrigley Field - Podcast tags: - Wrigley Field Renovations comments: - id: 14278 author: Michael Cotton author_email: '' author_url: '' date: '2014-10-27 19:28:09 +0000' date_gmt: '2014-10-28 00:28:09 +0000' content: Listened today. Great interview. ---
On this week's episode of They Ivy Envy Podcast, I'm joined by podcast listener, Danny Rockett. The Wrigley Field renovation is underway, and Danny goes to Wrigley on a daily basis to check on the progress. Since we, and many of our listeners are hours from Wrigley, we thought it'd be good to get Danny on to talk about the construction at Clark and Addison.
You can follow Danny on Twitter - @SonRanto
Here are a few more of Danny's pictures and a mesmerizing video he filmed as the bleachers came down.


Stakehouse Sports has created a new type of sports competition that is way more fun than your regular old pick 'em games.
Instead of just one team over the over, you predict the scores and earn points based on how good you predict the results.
Stakehouse Sports was built by Chris Aronchick and Paul Cullin.
We are both huge sports fans who also love fantasy sports, and we came up with Stakehouse Sports when we started talking about how we'd like to compete against each other.
Got ideas or questions? Send us an e-mail!


How to check in changes to existing ELT projects from Git Repository
The following steps will guide you to check in the changes made to existing ELT project from git repository.
1) Right click on project in project explorer > Team> Add to Index
2) Right click on project in project explorer > Team > Commit:
3)Select the required files to commit the changes
4) Enter commit message, drag the desired files to staged area and click on Commit: You can uncheck the files that are not required to be checked in.
5) Right click on Project in Project Explorer > Team> Push to Upstream
It will show the confirmation screen:


bill
Priority
Target date
Priority:
Client:
Product area:
Target date:
Success! Feature requests submitted.
Oh snap! Every field is required.
Psst! Priority must be a number


TopBanner - Logo/Slogan goes here
Menu Row - All the main menu buttons go there (including login/register) Once logged in, get a Dashboard that replaces Login
Testing
Bottom Bar - the Basic "Contact Us" and licensing info at the bottom of most pages


[ all classes ]
[ it.polimi.ingsw.view ]
Coverage Summary for Class: View (it.polimi.ingsw.view)
| Class |
|---|
| View |
1 package it.polimi.ingsw.view;
2
3 import it.polimi.ingsw.model.ReducedGod;
4 import it.polimi.ingsw.model.board.Position;
5 import it.polimi.ingsw.model.board.ReducedSpace;
6 import it.polimi.ingsw.model.enumerations.Color;
7
8 import java.util.List;
9
10 /**
11 * Defines a generic view to be implemented by each view type (e.g. CLI, GUI in JavaFX, ...).
12 */
13 public interface View {
14 /**
15 * Asks the user to choose a Nickname.
16 */
17 void askNickname();
18
19 /**
20 * Asks the user to choose the worker to be moved.
21 *
22 * @param positionList the list of available workers' positions.
23 */
24 void askMovingWorker(List<Position> positionList);
25
26 /**
27 * Asks the user the position where he wants to move the worker.
28 *
29 * @param positionList the list of valid move positions.
30 */
31 void askMove(List<Position> positionList);
32
33 /**
34 * Asks the user the initial positions of his workers.
35 *
36 * @param positions the list of available positions.
37 */
38 void askInitWorkersPositions(List<Position> positions);
39
40 /**
41 * Asks the user how many players he wants to play with.
42 */
43 void askPlayersNumber();
44
45 /**
46 * Allows the user to choose his workers' color.
47 *
48 * @param colors the list of the available colors.
49 */
50 void askInitWorkerColor(List<Color> colors);
51
52 /**
53 * Allows the user to choose his God.
54 *
55 * @param gods the list of the available Gods.
56 * @param request the number of gods to be selected by the user.
57 */
58 void askGod(List<ReducedGod> gods, int request);
59
60 /**
61 * Asks to the user to choose a new position where to build.
62 *
63 * @param positions the list of the available positions.
64 */
65 void askBuild(List<Position> positions);
66
67 /**
68 * Asks to the user to choose a new position where to move the worker.
69 * This method is called only when a effect is applied.
70 *
71 * @param positions the list of the available positions.
72 */
73 void askMoveFx(List<Position> positions);
74
75 /**
76 * Asks to the user to choose a new position where to build.
77 * This method is called only when a effect is applied.
78 *
79 * @param positions the list of the available positions.
80 */
81 void askBuildFx(List<Position> positions);
82
83 /**
84 * Shows to the user if the Login succeeded.
85 *
86 * @param nicknameAccepted indicates if the chosen nickname has been accepted.
87 * @param connectionSuccessful indicates if the connection has been successful.
88 * @param nickname the nickname of the player to be greeted.
89 */
90 void showLoginResult(boolean nicknameAccepted, boolean connectionSuccessful, String nickname);
91
92 /**
93 * Shows a generic message.
94 *
95 * @param genericMessage the generic message to be shown.
96 */
97 void showGenericMessage(String genericMessage);
98
99 /**
100 * Shows a disconnection message.
101 *
102 * @param nicknameDisconnected the nickname of the player who has disconnected.
103 * @param text a generic info text message.
104 */
105 void showDisconnectionMessage(String nicknameDisconnected, String text);
106
107 /**
108 * Shows an error message.
109 *
110 * @param error the error message to be shown.
111 */
112 void showErrorAndExit(String error);
113
114 /**
115 * Shows the board on the screen.
116 *
117 * @param spaces the board to be shown.
118 */
119 void showBoard(ReducedSpace[][] spaces);
120
121 /**
122 * Shows the lobby with connected players.
123 *
124 * @param nicknameList list of players.
125 * @param numPlayers number of players.
126 */
127 void showLobby(List<String> nicknameList, int numPlayers);
128
129 /**
130 * Asks the user if he wants to enable the effect.
131 *
132 * @param forceApply set to {@code true} to enable the effect without user interaction, {@code false} otherwise.
133 */
134 void askEnableEffect(boolean forceApply);
135
136 /**
137 * Shows the match info.
138 * Infos are about the active player, the other players and their gods.
139 *
140 * @param players the list of currently playing players.
141 * @param gods the list of gods chosen by each player.
142 * @param colors a list of player's color.
143 * @param activePlayer the currently active player (player's turn).
144 */
145 void showMatchInfo(List<String> players, List<ReducedGod> gods, List<Color> colors, String activePlayer);
146
147 /**
148 * Asks the "chosen player" who he wants the game to start from.
149 *
150 * @param nicknameList the list of nicknames of all the players.
151 * @param godList the list of gods of the players.
152 */
153 void askFirstPlayer(List<String> nicknameList, List<ReducedGod> godList);
154
155 /**
156 * Shows a win message.
157 *
158 * @param winner the nickname of the winner.
159 */
160 void showWinMessage(String winner);
161
162 }


--- status: "draft" title: "Required" text: 'Add <abbr class="ds-label__required" title="required">*</abbr> tag after legend text' ---


Each Jenkins instance maintains an RSA private/public key pair that can be used to uniquely identify Jenkins. This information is called "instance identity".
From outside, the public key can be obtained by sending the GET request to the top page of Jenkins, and look for the "X-Instance-Identity" header in the response. This header is always available, even if the response is 401 access denied (which can happen if Jenkins is protected via security.) The value represents a base64-encoded ASN.1 DER serialization of X.509 SubjectPublicKeyInfo record.
Plugins that run inside Jenkins can access this key pair programmatically through the org.jenkinsci.main.modules.instance_identity.InstanceIdentity class (add a provided scope dependency to this module into your plugin)
Possible Use
- Sometimes, a Jenkins server is accessible through multiple URLs. This ID can be used to identify duplicates in those.
- Plugins can use the private key to produce a digital signature of some data that can be verified later by other parties about its origin.


A friend (J) and I each took one tablet (75 mg) of amitriptyaline at 9:00pm Tuesday night.
9:00pm: Dosed.
9:45pm: Nothing.
10:00pm: Decided to walk to the grocery, about 15 minutes walking distance away. By the time we got there, we both noticed slurred speech, tingling in the extremities; and I noticed walking difficulties and slowed movement.
10:50pm: Back in the apartment; no true hallucinations or feelings of euphoria (speaking on behalf of J as well).
11:00pm: I alone dosed 40 mg diphenhydramine and one tablet of 5-HTP; note that neither of these substances were ingested in correlation of the Amy - this was just to help me sleep.
11:45pm: So tired I cannot move; J drifts in and out of sleep as well, reporting no interesting effects from the Amy aside from restless legs. I feel the same way.
Midnight: Fell asleep in a weird state of mind; woke up 17 hours later.
Not a very exciting drug, to say the least. I'll stick to sure-fire substances from now on.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


G'DAY MATE!
WE ARE TAYLORED MEDIA
ABOUT US
When you have an idea, complex concept or emotion that you want to pass on to someone else, you use some or all of the different types of media that human beings have developed and evolved through-out our history on this planet. The art of effective communication is one of our greatest and most valuable gifts. Different media can now be combined to maximize the effectiveness of communication. This is what is meant by the term 'Multimedia'. It is the combination of language, sound and visual images using Video, CD, DVD and of course, the Internet. When you include the added dimension of Interactivity, the picture is complete. Now the audience can participate in the communication experience. Interaction gives the user control over the information they are accessing and greatly enhances their experience in education, training, sales, and entertainment.
We are a company born and raised in the heartland of Australia. We started out in 2007 with humble beginnings at an internet café trying to help out a mother and daughter put their face on the internet. Soon after, we couldn’t keep up with the demand and formed a company called Taylored Media. From there, we have built our steps day by day adding 2 more members to the staff of the Taylored Media family. Now there are 4 of us coding, imaging and communicating along the coast of Australia, fine-tuning great business’ and their websites. Take a step into Multimedia with us and you will get to know the Taylored Media’s talent and vision for your company’s website.
OUR SERVICES
SEE WHAT WE'VE CREATED
CHECK OUT OUR PORTFOLIO
THE TECHNOLOGIES WE USE
CONTACT US
PO BOX 3347 Putney, N.S.W<EMAIL_ADDRESS>(02) 9816 4896


My name is Stefano Zuliani and I'll help you create your new digital garden with Lilium Digital Garden Template for Jekyll.
☕ If you like the template, please consider buying me a coffee.


{% extends "flat/flatpage.html" %} {% block title %}Open States Categorization{% endblock %} {% block flatpage %}
One of the ways that we add value to the data we provide is by attempting to categorize bills, actions, and votes across states.
Most state legislatures deal with more than bills. Despite the name of the bill objects in our data we take in all types of legislation that a state might produce. Generally looking at the bill_id will help you determine the type of legislation, but to make things easier across states we provide a "type"
field on bills.
Possible values:
Although most states follow very similar parlimentary procedure the names that their bill status systems use
for various actions almost never match up. To make analysis and the building of certain types of tools easier
we attempt to categorize about 30 types of common actions. In using our data you'll find these values in the
"type"
field of actions.
Possible values:
Similarly to actions, we make an effort to categorize the motion being voted upon. You'll find these values in the "type"
field of vote objects.
Possible values:
Many states provide a list of subject areas for individual pieces of legislation. We've made an attempt to map these to a comprehensive set of subjects.
If you're using the API data you'll find these in the "subjects"
field if we've been able to categorize a state's bills. If you're interested in the state's native categories those can be found in "scraped_subjects"
.
Possible values:


Most of the time you will use xSetupWithSchemaDataCommitTxn which does all of the above + optionally sets a schema and data.
const schema = `
name: string @index(exact) .
street: string @index(exact) .
`;
const sampleData = {
uid: "_:user",
name: "cameron",
addresses: [
{uid: "_:address1", street: "william", postcode: 2000},
{uid: "_:address2", street: "george", postcode: 2001},
{uid: "_:address3", street: "hay", postcode: 2444},
{uid: "_:address4", street: "short", postcode: 2107}
]
};
const {result, dgraphClient} = await xSetupWithSchemaDataCommitTxn({schema, data: sampleData});
Generated using TypeDoc
xGetSchemaMapTxn is useful for verifying you schema is what you think it is. Will ignore system predicates only returning the predicates you have set!
const schema = ` name: string @index(fulltext) . age: int . percent: float . awesome: bool . friend: uid @reverse . date: dateTime . location: geo . `; await xSetSchemaAlt(schema, dgraphClient); const schemaMap = await xGetSchemaMapTxn(dgraphClient); // check our schema expect(schemaMap.name.getType()).toBe('string'); expect(schemaMap.age.getType()).toBe('int');


Terror strike averted in Delhi, police arrest 3 men linked to Islamic State, recover IED
Police suspect the three men were influenced by the Islamic State. The three men were found carrying explosive materials used to devise bombs and IED.
by Arvind OjhaHIGHLIGHTS
- Police on Monday prevented a major terror strike in Delhi
- Police suspect the three men were influenced by the Islamic State
- All three were arrested from Assam's Guwahati
Delhi Police on Monday prevented a major terror strike in the Capital and apprehended three men linked to an Islamic State terror module and recovered Improvised Explosive Devices (IED) from them.
The three of them have been arrested from Assam's Guwahati. They have been identified as Muqaddas Islam, Ranjit Ali, Lewis Jamil Jamal.
DCP Pramod Kushwaha of Delhi Police Special Cell said, "A terror strike has been averted as three persons have been apprehended with Improvised Explosive Devices (IED)."
Police suspect the three men were influenced by the Islamic State. The three men were found carrying explosive materials used to devise bombs and IED.
Also Read | People forced to live in gas chambers in Delhi-NCR, better to kill them in one go: SC slams Centre, states
Also Watch | Missing girl could be in Trinidad or Tobago: Gujarat Police


| Class | ActiveMerchant::Billing::AuthorizeNetGateway |
| In: |
lib/active_merchant/billing/gateways/authorize_net.rb
|
| Parent: | Gateway |
For more information on the Authorize.Net Gateway please visit their Integration Center
The login and password are not the username and password you use to login to the Authorize.Net Merchant Interface. Instead, you will use the API Login ID as the login and Transaction Key as the password.
Automated Recurring Billing (ARB) is an optional service for submitting and managing recurring, or subscription-based, transactions.
To use recurring, update_recurring, and cancel_recurring ARB must be enabled for your account.
Information about ARB is available on the Authorize.Net website. Information about the ARB API is available at the Authorize.Net Integration Center
| API_VERSION | = | '3.1' |
| FRAUD_REVIEW | = | 1, 2, 3, 4 |
| RESPONSE_REASON_TEXT | = | 0, 2, 3 |
| CARD_CODE_RESPONSE_CODE | = | 5, 6, 38 |
| CARD_CODE_ERRORS | = | %w( N S ) |
| AVS_ERRORS | = | %w( A E N R W Z ) |
| AUTHORIZE_NET_ARB_NAMESPACE | = | 'AnetApi/xml/v1/schema/AnetApiSchema.xsd' |
| RECURRING_ACTIONS | = | { :create => 'ARBCreateSubscription', :update => 'ARBUpdateSubscription', :cancel => 'ARBCancelSubscription' |
Creates a new AuthorizeNetGateway
The gateway requires that a valid login and password be passed in the options hash.
# File lib/active_merchant/billing/gateways/authorize_net.rb, line 69 69: def initialize(options = {}) 70: requires!(options, :login, :password) 71: @options = options 72: super 73: end
Performs an authorization, which reserves the funds on the customer‘s credit card, but does not charge the card.
# File lib/active_merchant/billing/gateways/authorize_net.rb, line 83 83: def authorize(money, creditcard, options = {}) 84: post = {} 85: add_invoice(post, options) 86: add_creditcard(post, creditcard) 87: add_address(post, options) 88: add_customer_data(post, options) 89: 90: commit('AUTH_ONLY', money, post) 91: end
Cancel a recurring payment.
This transaction cancels an existing Automated Recurring Billing (ARB) subscription. Your account must have ARB enabled and the subscription must have already been created previously by calling recurring()
# File lib/active_merchant/billing/gateways/authorize_net.rb, line 221 221: def cancel_recurring(subscription_id) 222: request = build_recurring_request(:cancel, :subscription_id => subscription_id) 223: recurring_commit(:cancel, request) 224: end
Captures the funds from an authorized transaction.
# File lib/active_merchant/billing/gateways/authorize_net.rb, line 116 116: def capture(money, authorization, options = {}) 117: post = {:trans_id => authorization} 118: add_customer_data(post, options) 119: commit('PRIOR_AUTH_CAPTURE', money, post) 120: end
Credit an account.
This transaction is also referred to as a Refund and indicates to the gateway that money should flow from the merchant to the customer.
# File lib/active_merchant/billing/gateways/authorize_net.rb, line 146 146: def credit(money, identification, options = {}) 147: requires!(options, :card_number) 148: 149: post = { :trans_id => identification, 150: :card_num => options[:card_number] 151: } 152: add_invoice(post, options) 153: 154: commit('CREDIT', money, post) 155: end
Perform a purchase, which is essentially an authorization and capture in a single operation.
# File lib/active_merchant/billing/gateways/authorize_net.rb, line 100 100: def purchase(money, creditcard, options = {}) 101: post = {} 102: add_invoice(post, options) 103: add_creditcard(post, creditcard) 104: add_address(post, options) 105: add_customer_data(post, options) 106: 107: commit('AUTH_CAPTURE', money, post) 108: end
Create a recurring payment.
This transaction creates a new Automated Recurring Billing (ARB) subscription. Your account must have ARB enabled.
# File lib/active_merchant/billing/gateways/authorize_net.rb, line 178 178: def recurring(money, creditcard, options={}) 179: requires!(options, :interval, :duration, :billing_address) 180: requires!(options[:interval], :length, [:unit, :days, :months]) 181: requires!(options[:duration], :start_date, :occurrences) 182: requires!(options[:billing_address], :first_name, :last_name) 183: 184: options[:credit_card] = creditcard 185: options[:amount] = money 186: 187: request = build_recurring_request(:create, options) 188: recurring_commit(:create, request) 189: end
Update a recurring payment‘s details.
This transaction updates an existing Automated Recurring Billing (ARB) subscription. Your account must have ARB enabled and the subscription must have already been created previously by calling +recurring()+. The ability to change certain details about a recurring payment is dependent on transaction history and cannot be determined until after calling +update_recurring()+. See the ARB XML Guide for such conditions.
# File lib/active_merchant/billing/gateways/authorize_net.rb, line 206 206: def update_recurring(options={}) 207: requires!(options, :subscription_id) 208: request = build_recurring_request(:update, options) 209: recurring_commit(:update, request) 210: end
Void a previous transaction
# File lib/active_merchant/billing/gateways/authorize_net.rb, line 127 127: def void(authorization, options = {}) 128: post = {:trans_id => authorization} 129: commit('VOID', nil, post) 130: end


| Package | Description |
|---|---|
| weka.gui.knowledgeflow | |
| weka.knowledgeflow |
| Modifier and Type | Method and Description |
|---|---|
Flow |
TemplateManager.getBuiltinTemplateFlow(String flowDescription)
Get the built-in template flow corresponding to the description
|
Flow |
VisibleLayout.getFlow()
Get the flow being edited by this layout
|
Flow |
TemplateManager.getPluginTemplateFlow(String flowDescription)
Get the plugin template flow corresponding to the description
|
Flow |
TemplateManager.getTemplateFlow(String flowDescription)
Get the flow for the supplied description
|
| Modifier and Type | Method and Description |
|---|---|
void |
MainKFPerspective.copyFlowToClipboard(Flow flow) |
void |
VisibleLayout.setFlow(Flow flow)
Set the flow to edit in this layout
|
| Modifier and Type | Method and Description |
|---|---|
Flow |
Flow.copyFlow()
Make a copy of this Flow
|
Flow |
FlowExecutor.getFlow()
Get the flow to be executed
|
Flow |
FlowRunner.getFlow()
Get the flow to execute
|
static Flow |
Flow.JSONToFlow(String flowJSON)
Parse a Flow from the supplied JSON string
|
static Flow |
JSONFlowUtils.JSONToFlow(String flowJSON,
boolean dontComplainAboutMissingConnections)
Utility routine to deserialize a flow from the supplied JSON string
|
static Flow |
Flow.JSONToFlow(String flowJSON,
boolean dontComplainAboutMissingConnections)
Parse a Flow from the supplied JSON string
|
static Flow |
Flow.loadFlow(File flowFile,
Logger log)
Utility method to load a flow from a file
|
static Flow |
Flow.loadFlow(InputStream is,
FlowLoader loader)
Utility method to load a flow from the supplied input stream using the
supplied FlowLoader
|
static Flow |
Flow.loadFlow(Reader r,
FlowLoader loader)
Utility method to load a flow from the supplied reader using the supplied
FlowLoader
|
Flow |
JSONFlowLoader.readFlow(File flowFile)
Read the flow from the supplied file
|
Flow |
FlowLoader.readFlow(File flowFile)
Load a flow from the supplied file
|
Flow |
LegacyFlowLoader.readFlow(File flowFile)
Deserialize a legacy flow from the supplied file
|
static Flow |
JSONFlowUtils.readFlow(File file)
Read a flow from the supplied file
|
static Flow |
JSONFlowUtils.readFlow(File file,
boolean dontComplainAboutMissingConnections)
Read a flow from the supplied file
|
Flow |
JSONFlowLoader.readFlow(InputStream is)
Read the flow from the supplied input stream
|
Flow |
FlowLoader.readFlow(InputStream is)
Load a flow from the supplied input stream
|
Flow |
LegacyFlowLoader.readFlow(InputStream is)
Deserialize a legacy flow from the supplied input stream
|
static Flow |
JSONFlowUtils.readFlow(InputStream is)
Read a Flow from the supplied input stream
|
static Flow |
JSONFlowUtils.readFlow(InputStream is,
boolean dontComplainAboutMissingConnections)
Read a Flow from the supplied input stream
|
Flow |
JSONFlowLoader.readFlow(Reader r)
Read the flow from the supplied reader
|
Flow |
FlowLoader.readFlow(Reader r)
Load a flow from the supplied reader
|
Flow |
LegacyFlowLoader.readFlow(Reader r)
Deserialize a legacy flow from the supplied reader
|
static Flow |
JSONFlowUtils.readFlow(Reader sr)
Read a flow from the supplied reader
|
static Flow |
JSONFlowUtils.readFlow(Reader sr,
boolean dontComplainAboutMissingConnections)
Read a flow from the supplied reader
|
| Modifier and Type | Method and Description |
|---|---|
static String |
JSONFlowUtils.flowToJSON(Flow flow)
Utility routine to serialize a supplied flow to a JSON string
|
void |
FlowExecutor.setFlow(Flow flow)
Set the flow to be executed
|
void |
FlowRunner.setFlow(Flow flow)
Set the flow to execute
|
static void |
JSONFlowUtils.writeFlow(Flow flow,
File file)
Serializes the supplied flow to JSON and writes it out to the supplied file
|
static void |
JSONFlowUtils.writeFlow(Flow flow,
OutputStream os)
Serializes the supplied flow to JSON and writes out using the supplied
output stream
|
static void |
JSONFlowUtils.writeFlow(Flow flow,
Writer writer)
Serializes the supplied flow to JSON and writes out using the supplied
writer
|
Copyright © 2018 University of Waikato, Hamilton, NZ. All Rights Reserved.


Brief description of what this article accomplishes. Include any keywords indicated in the spreadsheet. This blurb will not appear with the content.
Install and Secure phpMyAdmin with NGINX - CentOS
Difficulty: 2
Time: 20 minutes
Installation
This article assumes you are installing on top of a Centos7 LEMP stack.
- Run epel-release to get the phpMyAdmin software
sudo yum install epel-release
- Install phpMyAdmin
sudo yum install phpmyadmin
- Link the phpmyadmin installed files to the Nginx document root.
sudo ln -s /usr/share/phpMyAdmin /usr/share/nginx/html
- Change the owner of the nginx sessions directory to nginx.
sudo chown nginx:nginx /var/lib/php/session
- Restart PHP
sudo systemctl restart php-fpm
- Restart nginx
sudo systemctl restart nginx
Verification
- Use your web browser to navigate to http://Your server IP address/phpmyadmin.
- login using
root
for user name and your MySql root password.

Securing your Server
There really is no such thing as being too paranoid when it comes to securing your database. For starters, anyone with your web address can tack on "phpmyadmin" and get to the phpmyadmin login screen. If they "guess" that your admin user is named "root", they are one correct guess away from administrative access to your database server.
The following are some simple steps you can take to back away from the edge of the cliff.
Change the name of the phpMyAdmin page
Right now, every hacker in the world knows the name of your phpMyAdmin page is http://your server or domain name/phpmyadmin. Let's start by making that name a bit more arcane.
- navigate to your document root directory:
cd /usr/share/nginx/html
- Change the name (actually, rename the symbolic link):
sudo mv phpmyadmin nodbhere
- Test by using your browser to navigate to http://your server or domain name/nodbhere.
Your browesr will display the phpmyadmin screen. You can also go to the old http://your server or domain name/phpmyadmin address but unless the page has been cached, you should get a "404 Not Found" error.
Use OpenSSL to add Nginx web authentication
Your Nginx install comes with OpenSSL, a tool that allows you to encrypt passwords.
- Create a password file, /etc/nginx/mypasswordfile, and open it for editing. Add your web user name (make one up) followed by a colon(:)
MyWebUserName:
- Save and close
- Encrypt a password
openssl passwd
Once you enter and confirm your password, openssl will return the encrypted version of it.
- Copy the encrypted version and paste it into your paswword file which now looks like this:
MyWebUserName:V.Cj1d1d1kew2
- Open your nginx configuration file or a file it references with an "include". It should look something like this:
# server context
server {
. . .
# location context
location / {
try_files $uri $uri/ =404;
}
# end of server context
}
- Create a new location context so that your file looks like this:
# server context
server {
. . .
# location context (existing)
location / {
try_files $uri $uri/ =404;
}
}
# location context (new)
location /nodbhere
{
auth_basic "MyWebLoginChallenge";
auth_basic_user_file /etc/nginx/mypasswordfile;
}
# end of server context
}
- Save and close
- Restart NGINX
sudo systemctl restart nginx
Next steps
You have just installed and secured phpmyadmin. Now you can take your time exploring the web-UI.


The deep meaning of your fragmented building information is hidden behind the invisible dependencies. Instead of storing data in siloed manner, VisuaLynk focuses on the relationships between each information entity. The explicitly represented relationships will allow you easily navigate in your data store and find the specific information that you are looking for.
Your business, your way! VisuaLynk's powerfull and easy-to-customize modules provides a flexible platform for the dynamic nature of your tasks, use-cases and business decisions. VisuaLynk does not force you to change your existing infrastructure and way of work. Instead, it integrates and expands them with each other.
Each of your data entities are automatically linked with each other on-fly. VisuaLynk's revolutionary Semantic Linked Data technology makes your fragmented data a click away with interactive links on www. Based on your business domain, VisuaLynk offers semantic graphs to serve a baseline data model for further customization to cater your industry specific needs.
Your building models are more intelligent with VisuaLynk's built-in interactive model viewers. Dynamically integrated 2D and 3D models building models will be an easy path to access semantic building information and it's explicit relationships.
Only text and numbers? Not anymore with VisuaLynk. Each information entity is represented with an easy-to-remember/recall visual icon. These icons are also linked with their explicit relationships. You don't need to shift between spreadsheets anymore. With VisuaLynk's built-in visual query system, related information will be on your screen with one click.
Machine Learning assisted data capture, mapping and analytic techniques provides intelligent assistance for your decision making process. With the semantic mapping and linking of your fragmented data, VisuaLynk offers efficient business solutions for our customers.


The theme defines a set of CSS custom properties you can use to apply a consistent color palette across your application.
If you are not importing any element themes, and want to use these colors, you need to import them manually.
Each color has two variations: the default variation which is used for the light theme, and another variation used for the dark theme.
The above example doesn’t work in IE11 or Edge 14. Read the compatibility instructions how to make the dark colors work in all supported browsers.
The most prominent color in the theme. It is used to bring attention to certain elements in the interface. An accompanying contrast color is also defined.
Usually a red color, used for things like error indicators, error messages and buttons that can cause permanent data loss.


jmap(1) jmap(1) Name jmap - Memory Map SYNOPSIS jmap [ option ] pid jmap [ option ] executable core jmap [ option ] [server-id@]remote-hostname-or-IP PARAMETERS option Options are mutually exclusive. Option, if used, should follow immediately after the command name. pid process id for which the memory map is to be printed. The process must be a Java process. To get a list of Java processes running on a machine, jps(1) may be used. executable Java executable from which the core dump was produced. core core file for which the memory map is to be printed. remote-hostname-or-IP remote debug server's (see jsadebugd(1)) hostname or IP address. server-id optional unique id, if multiple debug servers are running on the same remote host. DESCRIPTION jmap prints shared object memory maps or heap memory details of a given process or core file or a remote debug server. If the given process is running on a 64-bit VM, you may need to specify the -J-d64 option, e.g.: jmap -J-d64 -heap pid NOTE: This utility is unsupported and may or may not be available in future versions of the JDK. In Windows Systems where dbgeng.dll is not present, 'Debugging Tools For Windows' needs to be installed to have these tools working. Also, PATH environment variable should contain the location of jvm.dll used by the target process or the location from which the Crash Dump file was produced. For example, set PATH=<jdk>\jre\bin\client;%PATH% OPTIONS <no option> When no option is used jmap prints shared object mappings. For each shared object loaded in the target VM, start address, the size of the mapping, and the full path of the shared object file are printed. This is similar to the Solaris pmap utility. -dump:[live,]format=b,file=<filename> Dumps the Java heap in hprof binary format to filename. The live suboption is optional. If specified, only the live objects in the heap are dumped. To browse the heap dump, you can use jhat(1) (Java Heap Analysis Tool) to read the generated file. -finalizerinfo Prints information on objects awaiting finalization. -heap Prints a heap summary. GC algorithm used, heap configuration and generation wise heap usage are printed. -histo[:live] Prints a histogram of the heap. For each Java class, number of objects, memory size in bytes, and fully qualified class names are printed. VM internal class names are printed with '*' prefix. If the live suboption is specified, only live objects are counted. -permstat Prints class loader wise statistics of permanent generation of Java heap. For each class loader, its name, liveness, address, parent class loader, and the number and size of classes it has loaded are printed. In addition, the number and size of interned Strings are printed. -F Force. Use with jmap -dump or jmap -histo option if the pid does not respond. The live suboption is not supported in this mode. -h Prints a help message. -help Prints a help message. -J<flag> Passes <flag> to the Java virtual machine on which jmap is run. SEE ALSO o pmap(1) o jhat(1) o jps(1) o jsadebugd(1) 16 Mar 2012 jmap(1)


Policy, Procedure, and Audit Status
This site consolidates all documents related to the Granada Compliance Program
Control Tracking
Satisfied Controls
61
Total Controls
61
Narratives Provide an overview of the organization and the compliance environment.
| Name | Acronym | |
|---|---|---|
| Control Environment Narrative | CEN | Granada-CEN.pdf |
| Organizational Narrative | ON | Granada-ON.pdf |
| Products and Services Narrative | PSN | Granada-PSN.pdf |
| Security Architecture Narrative | SEN | Granada-SEN.pdf |
| System Architecture Narrative | SAN | Granada-SAN.pdf |
Policies govern the behavior of Granada employees and contractors.
| Name | Acronym | |
|---|---|---|
| Access Onboarding and Termination Policy | AOTP | Granada-AOTP.pdf |
| Application Security Policy | ASP | Granada-ASP.pdf |
| Availability Policy | AP | Granada-AP.pdf |
| System Change Policy | SCP | Granada-SCP.pdf |
| Data Classification Policy | DCP | Granada-DCP.pdf |
| Code of Conduct Policy | COCP | Granada-COCP.pdf |
| Confidentiality Policy | CP | Granada-CP.pdf |
| Business Continuity Policy | BCP | Granada-BCP.pdf |
| Cyber Risk Assessment Policy | CRP | Granada-CRP.pdf |
| Datacenter Policy | DP | Granada-DP.pdf |
| Software Development Lifecycle Policy | SDLCP | Granada-SDLCP.pdf |
| Disaster Recovery Policy | DRP | Granada-DRP.pdf |
| Encryption Policy | EP | Granada-EP.pdf |
| Security Incident Response Policy | SIRP | Granada-SIRP.pdf |
| Information Security Policy | ISP | Granada-ISP.pdf |
| Log Management Policy | LMP | Granada-LMP.pdf |
| Removable Media and Cloud Storage Policy | MCP | Granada-MCP.pdf |
| Office Security Policy | OSP | Granada-OSP.pdf |
| Password Policy | PWP | Granada-PWP.pdf |
| Policy Training Policy | PTP | Granada-PTP.pdf |
| Privacy Management Policy | PMP | Granada-PMP.pdf |
| Processing Integrity Policy | PIP | Granada-PIP.pdf |
| Remote Access Policy | REAP | Granada-REAP.pdf |
| Data Retention Policy | RP | Granada-RP.pdf |
| Risk Assessment Policy | RIAP | Granada-RIAP.pdf |
| Vendor Management Policy | VMP | Granada-VMP.pdf |
| Workstation Policy | WP | Granada-WP.pdf |
Procedures Prescribe specific steps that are taken in response to key events.
| Name | ID | Schedule (cron format) |
|---|---|---|
| Offboard User | offboard | On demand |
| Onboard New User | onboard | On demand |
| Apply OS patches | patch | 0 0 0 15 * * |
| Collect Workstation Details | workstation | 0 0 0 15 4 * |
Standards Specify the controls satisfied by the compliance program.
| Control Key | Name | Satisfied? | Satisfied By |
|---|---|---|---|
| A1.1 |
Capacity Planning
The entity maintains, monitors, and evaluates current processing capacity and use of system components (infrastructure, data, and software) to manage capacity demand and to enable the implementation of additional capacity to help meet its objectives
|
Yes | Granada-AP.pdf |
| A1.2 |
Backup and Recovery
The entity authorizes, designs, develops or acquires, implements, operates, approves, maintains, and monitors environmental protections, software, data back-up processes, and recovery infrastructure to meet its objectives
|
Yes | Granada-DRP.pdf |
| A1.3 |
Recovery Testing
The entity tests recovery plan procedures supporting system recovery to meet its objectives
|
Yes | Granada-DRP.pdf |
| C1.1 |
Confidential Information Identification
The entity identifies and maintains confidential information to meet the entity’s objectives related to confidentiality
|
Yes | Granada-CP.pdf |
| C1.2 |
Confidential Information Disposal
The entity disposes of confidential information to meet the entity’s objectives related to confidentiality.
|
Yes | Granada-CP.pdf |
| CC1.1 |
Integrity and Ethics
The entity demonstrates a commitment to integrity and ethical values
|
Yes | Granada-COCP.pdf |
| CC1.2 |
Board Independence
The board of directors demonstrates independence from management and exercises oversight of the development and performance of internal control
|
Yes | Granada-ON.pdf Granada-RP.pdf |
| CC1.3 |
Organizational Structure
Management establishes, with board oversight, structures, reporting lines, and appropriate authorities and responsibilities in the pursuit of objectives
|
Yes | Granada-ON.pdf |
| CC1.4 |
Hiring, Training and Retention
The entity demonstrates a commitment to attract, develop, and retain competent individuals in alignment with objectives
|
Yes | Granada-ON.pdf |
| CC1.5 |
Individual Accountability
The entity holds individuals accountable for their internal control responsibilities in the pursuit of objectives.
|
Yes | Granada-ON.pdf |
| CC2.1 |
Use of Information Systems
The entity obtains or generates and uses relevant, quality information to support the functioning of internal control
|
Yes | Granada-CEN.pdf |
| CC2.2 |
Use of Communication Systems, Internal
The entity internally communicates information, including objectives and responsibilities for internal control, necessary to support the functioning of internal control
|
Yes | Granada-CEN.pdf |
| CC2.3 |
Use of Communication Systems, External
The entity communicates with external parties regarding matters affecting the functioning of internal control
|
Yes | Granada-CEN.pdf |
| CC3.1 |
Objectives
The entity specifies objectives with sufficient clarity to enable the identification and assessment of risks relating to objectives
|
Yes | Granada-ON.pdf |
| CC3.2 |
Risk to Objectives
The entity identifies risks to the achievement of its objectives across the entity and analyzes risks as a basis for determining how the risks should be managed
|
Yes | Granada-ON.pdf |
| CC3.3 |
Fraud Risk to Objectives
The entity considers the potential for fraud in assessing risks to the achievement of objectives
|
Yes | Granada-ON.pdf |
| CC3.4 |
Impact of Changes
The entity identifies and assesses changes that could significantly impact the system of internal control
|
Yes | Granada-SCP.pdf |
| CC4.1 |
Monitoring
The entity selects, develops, and performs ongoing and/or separate evaluations to ascertain whether the components of internal control are present and functioning
|
Yes | Granada-CEN.pdf |
| CC4.2 |
Remediation
The entity evaluates and communicates internal control deficiencies in a timely manner to those parties responsible for taking corrective action, including senior management and the board of directors, as appropriate
|
Yes | Granada-CEN.pdf |
| CC5.1 |
Objective Risk Mitigation
The entity selects and develops control activities that contribute to the mitigation of risks to the achievement of objectives to acceptable levels
|
Yes | Granada-CEN.pdf |
| CC5.2 |
Technology Controls
The entity also selects and develops general control activities over technology to support the achievement of objectives
|
Yes | Granada-CEN.pdf |
| CC5.3 |
Established Policies
The entity deploys control activities through policies that establish what is expected and in procedures that put policies into action
|
Yes | Granada-CEN.pdf |
| CC6.1 |
Logical Access
The entity implements logical access security software, infrastructure, and architectures over protected information assets to protect them from security events to meet the entity’s objectives
|
Yes | Granada-AOTP.pdf Granada-REAP.pdf |
| CC6.2 |
User Access
Prior to issuing system credentials and granting system access, the entity registers and authorizes new internal and external users whose access is administered by the entity. For those users whose access is administered by the entity, user system credentials are removed when user access is no longer authorized
|
Yes | Granada-AOTP.pdf Granada-ASP.pdf Granada-REAP.pdf |
| CC6.3 |
Role-Based Access
The entity authorizes, modifies, or removes access to data, software, functions, and other protected information assets based on roles, responsibilities, or the system design and changes, giving consideration to the concepts of least privilege and segregation of duties, to meet the entity’s objectives
|
Yes | Granada-AOTP.pdf |
| CC6.4 |
Physical Access
The entity restricts physical access to facilities and protected information assets (for example, data center facilities, back-up media storage, and other sensitive locations) to authorized personnel to meet the entity’s objectives
|
Yes | Granada-DP.pdf Granada-OSP.pdf |
| CC6.5 |
Data Disposal
The entity discontinues logical and physical protections over physical assets only after the ability to read or recover data and software from those assets has been diminished and is no longer required to meet the entity’s objectives
|
Yes | Granada-RP.pdf |
| CC6.6 |
External Threats
The entity implements logical access security measures to protect against threats from sources outside its system boundaries
|
Yes | Granada-SEN.pdf |
| CC6.7 |
Data Custody and Transmission
The entity restricts the transmission, movement, and removal of information to authorized internal and external users and processes, and protects it during transmission, movement, or removal to meet the entity’s objectives
|
Yes | Granada-SEN.pdf Granada-MCP.pdf Granada-REAP.pdf |
| CC6.8 |
Malware Detection
The entity implements controls to prevent or detect and act upon the introduction of unauthorized or malicious software to meet the entity’s objectives
|
Yes | Granada-WP.pdf |
| CC7.1 |
Vulnerability Detection
To meet its objectives, the entity uses detection and monitoring procedures to identify (1) changes to configurations that result in the introduction of new vulnerabilities, and (2) susceptibilities to newly discovered vulnerabilities
|
Yes | Granada-SEN.pdf |
| CC7.2 |
Anomaly Detection
The entity monitors system components and the operation of those components for anomalies that are indicative of malicious acts, natural disasters, and errors affecting the entity’s ability to meet its objectives; anomalies are analyzed to determine whether they represent security events
|
Yes | Granada-SEN.pdf Granada-LMP.pdf |
| CC7.3 |
Security Incident Evaluation
The entity evaluates security events to determine whether they could or have resulted in a failure of the entity to meet its objectives (security incidents) and, if so, takes actions to prevent or address such failures
|
Yes | Granada-SIRP.pdf |
| CC7.4 |
Security Incident Response Plan
The entity responds to identified security incidents by executing a defined incident response program to understand, contain, remediate, and communicate security incidents, as appropriate
|
Yes | Granada-SIRP.pdf |
| CC7.5 |
Security Incident Response Execution
The entity identifies, develops, and implements activities to recover from identified security incidents
|
Yes | Granada-SIRP.pdf |
| CC8.1 |
Change Control
The entity authorizes, designs, develops or acquires, configures, documents, tests, approves, and implements changes to infrastructure, data, software, and procedures to meet its objectives
|
Yes | Granada-SCP.pdf Granada-SDLCP.pdf |
| CC9.1 |
Disruption Risk Mitigation
The entity identifies, selects, and develops risk mitigation activities for risks arising from potential business disruptions
|
Yes | Granada-AP.pdf Granada-BCP.pdf Granada-CRP.pdf Granada-RIAP.pdf |
| CC9.2 |
Vendor Risk Management
The entity assesses and manages risks associated with vendors and business partners
|
Yes | Granada-VMP.pdf |
| P1.1 |
Privacy Notification
The entity provides notice to data subjects about its privacy practices to meet the entity’s objectives related to privacy. The notice is updated and communicated to data subjects in a timely manner for changes to the entity’s privacy practices, including changes in the use of personal information, to meet the entity’s objectives related to privacy
|
Yes | Granada-PMP.pdf |
| P2.1 |
Privacy Consent and Choice
The entity communicates choices available regarding the collection, use, retention, disclosure, and disposal of personal information to the data subjects and the consequences, if any, of each choice. Explicit consent for the collection, use, retention, disclosure, and disposal of personal information is obtained from data subjects or other authorized persons, if required. Such consent is obtained only for the intended purpose of the information to meet the entity’s objectives related to privacy. The entity’s basis for determining implicit consent for the collection, use, retention, disclosure, and disposal of personal information is documented
|
Yes | Granada-PMP.pdf |
| P3.1 |
Personal Information Collection
Personal information is collected consistent with the entity’s objectives related to privacy
|
Yes | Granada-PMP.pdf |
| P3.2 |
Explicit Consent
For information requiring explicit consent, the entity communicates the need for such consent, as well as the consequences of a failure to provide consent for the request for personal information, and obtains the consent prior to the collection of the information to meet the entity’s objectives related to privacy
|
Yes | Granada-PMP.pdf |
| P4.1 |
Proper Use of Personal Information
The entity limits the use of personal information to the purposes identified in the entity’s objectives related to privacy
|
Yes | Granada-PMP.pdf |
| P4.2 |
Personal Information Retention
The entity retains personal information consistent with the entity’s objectives related to privacy
|
Yes | Granada-PMP.pdf Granada-RP.pdf |
| P4.3 |
Personal Information Disposal
The entity securely disposes of personal information to meet the entity’s objectives related to privacy
|
Yes | Granada-PMP.pdf |
| P5.1 |
Data Subject Access
The entity grants identified and authenticated data subjects the ability to access their stored personal information for review and, upon request, provides physical or electronic copies of that information to data subjects to meet the entity’s objectives related to privacy. If access is denied, data subjects are informed of the denial and reason for such denial, as required, to meet the entity’s objectives related to privacy
|
Yes | Granada-PMP.pdf |
| P5.2 |
Data Subject Amendment
The entity corrects, amends, or appends personal information based on information provided by data subjects and communicates such information to third parties, as committed or required, to meet the entity’s objectives related to privacy. If a request for correction is denied, data subjects are informed of the denial and reason for such denial to meet the entity’s objectives related to privacy
|
Yes | Granada-PMP.pdf |
| P6.1 |
Consent for Third Party Disclosure
The entity discloses personal information to third parties with the explicit consent of data subjects, and such consent is obtained prior to disclosure to meet the entity’s objectives related to privacy
|
Yes | Granada-PMP.pdf |
| P6.2 |
Authorized Disclosures
The entity creates and retains a complete, accurate, and timely record of authorized disclosures of personal information to meet the entity’s objectives related to privacy
|
Yes | Granada-PMP.pdf |
| P6.3 |
Unauthorized Disclosures
The entity creates and retains a complete, accurate, and timely record of detected or reported unauthorized disclosures (including breaches) of personal information to meet the entity’s objectives related to privacy
|
Yes | Granada-PMP.pdf |
| P6.4 |
Appropriate Third Party Disclosure
The entity obtains privacy commitments from vendors and other third parties who have access to personal information to meet the entity’s objectives related to privacy. The entity assesses those parties’ compliance on a periodic and as-needed basis and takes corrective action, if necessary
|
Yes | Granada-PMP.pdf |
| P6.5 |
Unauthorized Third Party Disclosure
The entity obtains commitments from vendors and other third parties with access to personal information to notify the entity in the event of actual or suspected unauthorized disclosures of personal information. Such notifications are reported to appropriate personnel and acted on in accordance with established incident response procedures to meet the entity’s objectives related to privacy
|
Yes | Granada-PMP.pdf |
| P6.6 |
Notification of Unauthorized Third Party Disclosure
The entity provides notification of breaches and incidents to affected data subjects, regulators, and others to meet the entity’s objectives related to privacy
|
Yes | Granada-PMP.pdf |
| P6.7 |
Accounting of Personal Information
The entity provides data subjects with an accounting of the personal information held and disclosure of the data subjects’ personal information, upon the data subjects’ request, to meet the entity’s objectives related to privacy
|
Yes | Granada-PMP.pdf |
| P7.1 |
Accuracy of Personal Information
The entity collects and maintains accurate, up-to-date, complete, and relevant personal information to meet the entity’s objectives related to privacy
|
Yes | Granada-PMP.pdf |
| P8.1 |
Personal Information Dispute Resolution
The entity implements a process for receiving, addressing, resolving, and communicating the resolution of inquiries, complaints, and disputes from data subjects and others and periodically monitors compliance to meet the entity’s objectives related to privacy. Corrections and other necessary actions related to identified deficiencies are made or taken in a timely manner
|
Yes | Granada-PMP.pdf |
| PI1.1 |
Processing Integrity Monitoring
The entity obtains or generates, uses, and communicates relevant, quality information regarding the objectives related to processing, including de nitions of data processed and product and service speci cations, to support the use of products and services
|
Yes | Granada-PIP.pdf |
| PI1.2 |
Processing Integrity Accuracy
The entity implements policies and procedures over system inputs, including controls over completeness and accuracy, to result in products, services, and reporting to meet the entity’s objectives
|
Yes | Granada-PIP.pdf |
| PI1.3 |
Processing Integrity Operations
The entity implements policies and procedures over system processing to result in products, services, and reporting to meet the entity’s objectives
|
Yes | Granada-PIP.pdf |
| PI1.4 |
Processing Integrity Outputs
The entity implements policies and procedures to make available or deliver output completely, accurately, and timely in accordance with speci cations to meet the entity’s objectives
|
Yes | Granada-PIP.pdf |
| PI1.5 |
Processing Integrity Backups
The entity implements policies and procedures to store inputs, items in processing, and outputs completely, accurately, and timely in accordance with system speci cations to meet the entity’s objectives
|
Yes | Granada-PIP.pdf |


by Joćo Pedro Neto and Bill Taylor
"Spin, slave, revolve around yourself!" - said the
mad stable King
We (Bill Taylor and Joao Neto) have invented and started to play some games with a common rule theme: if some condition is met, the moved piece changes its powers. Like a game with rotating officials. This, if done well, can result in very dynamic games, where some pieces lead very wild lives.
Joao invented a game based on a simple idea: depending whether the turn number is even/odd, the moved piece is promoted/demoted. This basic change makes (in Joao's opinion) a very good chess variant, called Promotions and Demotions, or just ProDem. But, is this the only possible way to use this dynamic idea?
There is an old chess variant, named Revolving Chess (whose origins we don't know), whose rules are:
REVOLVING CHESS
- Knight to Bishop,
- Bishop to Rook
- Rook to Queen
- Queen to Knight
note: The original game was fully "royal", but we play with stalemate = win for stalemater, though still with castling (R changing to Q).
REVOLVING CHESS Game Sample
1. d4 d5
11. R:c8(Q) Qa:c8(N) 21. Q:f6(N)+ g:f6
2. c4 d:c4 12. B:a5(R) e:d4
22. Ba6(R) Kg7
3. Nc3(B) b5 13. Rb5(Q)+ Nc6(B) 23.
Rha1(Q) Qe8(N)
4. a4 c6 14. Q:c6(N) R:c6(Q)
24. Ke3 Ncd6(B)
5. a:b5 c:b5 15. Q:d4(N) Q:d4(N) 25: R:d6(Q)
N:d6(B)
6. b3 a5 16. e:d4
Nf6(B) 26. h3 Be5(R)+
7. b:c4 b:c4 17. Bf4(R) O-O(Q) 27.
Q:e5(N) f:e5
8. e3 R:a6(Q) 18. Ra6(Q) Qc2(N)+ 28. Ke4
f3
9. Ne2(B) e5 19. Kd2 N:d4(B)
29. Kf5 Kf7
10 B:c4(R) Bd6(R) 20.  k .  p .
Since Revolving Chess is the older game, we may think of it as the standard revolving positional game in this text, despite the fact that Promotions and Demotions was an independent discovery. In fact, ProDem was the first game we played, and it was then that many different and yet related ideas appeared. Firstly, the rules of ProDem:
PROMOTIONS & DEMOTIONS [aka "even-up, odd-down"]
notes:
Here goes two sample games:
1. -- Nf6(P) 11.
Rc5(B) Rh4(N) 21. B:e6(p)+ Kd7
2. c4(B) e6(B) 12. Nc3(R) N:g2(R) 22. R:c5(Q)+ K:e6
3. B:e6(P) Qe7(R) 13. Rb1(B) B:a2(P) 23. Rf5(B)+ Kf7
4. e:f7(B) R:B(Q) 14. Bh7(R) Bc6(R) 24. Rf8(Q)+ 1-0
5. Qc2(R) Nc6(P) 15. Rhf1(B) Rg6(N)
6. g3(B) h5(N) 16. Bg2(R) a6(N)
7. Bg2(P) N:g3(P) 17. R:g6(B) Q:g6(R)
8. f:g3(B) d6(B) 18. Rh8(Q)+ Kf7
9. B:d6(P) B:d6(P) 19. Qxa8(R) Nxc5(P)
10 Nf3(R) d5(B) 20. b3(B) b5(B)
Final Position:
. . . . . Q . .
. . p . . k p .
. . p . . p r .
. b Q . .
p . . O O . . O
. . B . K . . .
note: even if these games have non royal Kings, we still use the + symbol which means some piece is attacking the King
1. -- Nc3(P)
11. g6:f7(B)+ K:f7 21. Be8(R)+ Kd7
2. b3(B) d5(B) 12. Rh5(B)+ Ke7
22. Re8e5(N)+ Ke6
3. Bb2(P) Bf5(P) 13. d3(N) a5(B)
23. Bh3(R) a1(B)
4. c4(B) e6(B) 14. Kd2
Ba:Rc3(P)+ 24. Kf1 B:e5(P)
5. Ne3(P) Bc4:B(P) 15. b2:c3(B) Nf6(R) 25.
resigns 0-1
6. h4(B) c4:B(B) 16. Ke1
Rg8(B)
7. Bh4:Q(P) Bb3:Q(P) 17. g4(N) Rf5(Q)
8. Nc3(R) Ra8:P(Q) 18. Bf6(P)+ Qxf6(R)
9. Rb1(B) g6(B) 19. Ne5(R)+ Re6(Q)
10.Bb1xB(P) Be6:P(P) 20. R:Qe6(N) K:e6
Final Position:
. . . q .  p .  p .  O . R
. . . .  p . K . .
Other remarks:
Well, taking different behavior given a turn number is one possibility, others exist:
These options can be divided into two groups, where the game is completely defined by presenting:
Notice that in this classification, FIDE Chess belongs to group b), as it may be necessary to state that a King is moved (for castling) or if some pawn was moved (to make en passant capturing). We both feel that group a) games are more elegant, (but that does not mean dropping the others!! :)
With that last point as motivation, Bill invented the next game:
MOVE UP, TAKE DOWN
We would like you to specially notice rule 5. Its motivation was to ensure that a board with no pawns would no longer require knowledge of its *orientation*, similar to the "no-external-info" mentioned above. However, it has resulted in a new idea:- that when a certain condition is true (no pawns), the game dynamics changes. This is not a common feature in Chess Variants, but may be an excellent concept to extend.
And here goes a sample game:
1. g4(N) d5(N) 11. B:a1(N) B:a1(N) 21.
Ke2 Re8(Q)+ 31. Q:a1(R) Ng4(B)+
2. e3(N) f6(N) 12. R:e7(B) K:e7 22. Kd1
Na6(B) 32. Kc2 R:d2(B)
3. Ne:N(P) Q:d5(R) 13. Ba3(R) Bd7(R) 23. Rf1(Q) B:d3(N) 33.
K:d2 Qe4(N)+
4. b4(N) b6(N) 14. Nf3(B) Rd6(Q) 24. Q:d3(R) g5(N)
34. Kd3 Nd6(B)?
5. c4(N) a6(N) 15. Rd3(Q) Nc5(B) 25. h4(N)
Ne4(B) 35. Bg8(R)+ Bf8(R)
6. N:f6(P) e:f6(Q) 16. Be4(R)+ Kd8 26. Rc3(Q)+ Kd8
36. R:g4(B) Rf6(Q)
7. N:b6(P) c:b6(Q) 17. Rh4(Q)+ Kc7 27. Nf3(B) B:d5(N)
37. Ra5(Q)+ 1-0
8. Be2(R)+ Be7(R) 18. Q:a1(R) B:f2(N) 28. B:d5(N) Q:d5(R)
9. N:d5(P) Q:a1(R) 19. Q:f2(R) Q:f2(R) 29. a3(N) h6(N)
10 Nc3(B) Nf6(B) 20. K:f2 Ra7(Q)+ 30. Nc4(B)
Q:a1(R)+
Final Position:
. . . k .  q . .
 B .
. . .


esys.downunder.forwardmodels.magnetotelluric2d Package¶
Forward models for 2D MT (TE and TM mode)
Classes¶
-
class
esys.downunder.forwardmodels.magnetotelluric2d.
ForwardModel
¶ Bases:
object
An abstract forward model that can be plugged into a cost function. Subclasses need to implement
getDefect()
,getGradient()
, and possiblygetArguments()
and ‘getCoordinateTransformation’.-
__init__
()¶ Initialize self. See help(type(self)) for accurate signature.
-
getArguments
(x)¶
-
getCoordinateTransformation
()¶
-
getDefect
(x, *args)¶
-
getGradient
(x, *args)¶
-
-
class
esys.downunder.forwardmodels.magnetotelluric2d.
MT2DBase
(domain, omega, x, Z, eta=None, w0=1.0, mu=1.2566370614359173e-06, sigma0=0.01, airLayerLevel=None, fixAirLayer=False, coordinates=None, tol=1e-08, saveMemory=False, directSolver=True)¶ Bases:
esys.downunder.forwardmodels.base.ForwardModel
Base class for 2D MT forward models. See
MT2DModelTEMode
andMT2DModelTMMode
for actual implementations.-
__init__
(domain, omega, x, Z, eta=None, w0=1.0, mu=1.2566370614359173e-06, sigma0=0.01, airLayerLevel=None, fixAirLayer=False, coordinates=None, tol=1e-08, saveMemory=False, directSolver=True)¶ initializes a new forward model.
Parameters: - domain (
Domain
) – domain of the model - omega (positive
float
) – frequency - x (
list
oftuple
withfloat
) – coordinates of measurements - Z (
list
ofcomplex
) – measured impedance (possibly scaled) - eta (positive
float
orlist
of positivefloat
) – spatial confidence radius - w0 (
None
or a list of positivefloat
) – confidence factors for meassurements. - mu (
float
) – permeability - sigma0 (
float
) – background conductivity - airLayerLevel (
float
orNone
) – position of the air layer from to bottom of the domain. If not set the air layer starts at the top of the domain - fixAirLayer (
bool
) – fix air layer (TM mode) - coordinates (
ReferenceSystem
orSpatialCoordinateTransformation
) – defines coordinate system to be used (not supported yet) - tol (positive
float
) – tolerance of underlying PDE - saveMemory (
bool
) – if true stiffness matrix is deleted after solution of the PDE to minimize memory use. This will require more compute time as the matrix needs to be reallocated at each iteration. - directSolver (
bool
) – if true a direct solver (rather than an iterative solver) will be used to solve the PDE
- domain (
-
getArguments
(x)¶ Returns precomputed values shared by
getDefect()
andgetGradient()
. Needs to be implemented in subclasses.
-
getCoordinateTransformation
()¶ returns the coordinate transformation being used
Return type: CoordinateTransformation
-
getDefect
(x, Ex, dExdz)¶ Returns the defect value. Needs to be implemented in subclasses.
-
getDomain
()¶ Returns the domain of the forward model.
Return type: Domain
-
getGradient
(x, Ex, dExdz)¶ Returns the gradient. Needs to be implemented in subclasses.
-
getWeightingFactor
(x, wx0, x0, eta)¶ returns the weighting factor
-
setUpPDE
()¶ Return the underlying PDE.
Return type: LinearPDE
-
-
class
esys.downunder.forwardmodels.magnetotelluric2d.
MT2DModelTEMode
(domain, omega, x, Z_XY, eta=None, w0=1.0, mu=1.2566370614359173e-06, sigma0=0.01, airLayerLevel=None, coordinates=None, Ex_top=1, fixAtTop=False, tol=1e-08, saveMemory=False, directSolver=True)¶ Bases:
esys.downunder.forwardmodels.magnetotelluric2d.MT2DBase
Forward Model for two dimensional MT model in the TE mode for a given frequency omega. It defines a cost function:
- defect = 1/2 integrate( sum_s w^s * ( E_x/H_y - Z_XY^s ) ) ** 2 *
where E_x is the horizontal electric field perpendicular to the YZ-domain, horizontal magnetic field H_y=1/(i*omega*mu) * E_{x,z} with complex unit i and permeability mu. The weighting factor w^s is set to
- w^s(X) = w_0^s *
if length(X-X^s) <= eta and zero otherwise. X^s is the location of impedance measurement Z_XY^s, w_0^s is the level of confidence (eg. 1/measurement error) and eta is level of spatial confidence.
E_x is given as solution of the PDE
- -E_{x,ii} - i omega * mu * sigma * E_x = 0
where E_x at top and bottom is set to solution for background field. Homogeneous Neuman conditions are assumed elsewhere.
-
__init__
(domain, omega, x, Z_XY, eta=None, w0=1.0, mu=1.2566370614359173e-06, sigma0=0.01, airLayerLevel=None, coordinates=None, Ex_top=1, fixAtTop=False, tol=1e-08, saveMemory=False, directSolver=True)¶ initializes a new forward model. See base class for a description of the arguments.
-
getArguments
(sigma)¶ Returns precomputed values shared by
getDefect()
andgetGradient()
.Parameters: sigma ( Data
of shape (2,)) – conductivityReturns: E_x, E_z Return type: Data
of shape (2,)
-
getCoordinateTransformation
()¶ returns the coordinate transformation being used
Return type: CoordinateTransformation
-
getDefect
(sigma, Ex, dExdz)¶ Returns the defect value.
Parameters: - sigma (
Data
of shape ()) – a suggestion for conductivity - Ex (
Data
of shape (2,)) – electric field - dExdz (
Data
of shape (2,)) – vertical derivative of electric field
Return type: float
- sigma (
-
getDomain
()¶ Returns the domain of the forward model.
Return type: Domain
-
getGradient
(sigma, Ex, dExdz)¶ Returns the gradient of the defect with respect to density.
Parameters: - sigma (
Data
of shape ()) – a suggestion for conductivity - Ex (
Data
of shape (2,)) – electric field - dExdz (
Data
of shape (2,)) – vertical derivative of electric field
- sigma (
-
getWeightingFactor
(x, wx0, x0, eta)¶ returns the weighting factor
-
setUpPDE
()¶ Return the underlying PDE.
Return type: LinearPDE
-
class
esys.downunder.forwardmodels.magnetotelluric2d.
MT2DModelTMMode
(domain, omega, x, Z_YX, eta=None, w0=1.0, mu=1.2566370614359173e-06, sigma0=0.01, airLayerLevel=None, coordinates=None, tol=1e-08, saveMemory=False, directSolver=True)¶ Bases:
esys.downunder.forwardmodels.magnetotelluric2d.MT2DBase
Forward Model for two-dimensional MT model in the TM mode for a given frequency omega. It defines a cost function:
- defect = 1/2 integrate( sum_s w^s * ( rho*H_x/Hy - Z_YX^s ) ) ** 2 *
where H_x is the horizontal magnetic field perpendicular to the YZ-domain, horizontal magnetic field H_y=1/(i*omega*mu) * E_{x,z} with complex unit i and permeability mu. The weighting factor w^s is set to
- w^s(X) = w_0^s *
if length(X-X^s) <= eta and zero otherwise. X^s is the location of impedance measurement Z_XY^s, w_0^s is the level of confidence (eg. 1/measurement error) and eta is level of spatial confidence.
H_x is given as solution of the PDE
- -(rho*H_{x,i})_{,i} + i omega * mu * H_x = 0
where H_x at top and bottom is set to solution for background field. Homogeneous Neuman conditions are assumed elsewhere.
-
__init__
(domain, omega, x, Z_YX, eta=None, w0=1.0, mu=1.2566370614359173e-06, sigma0=0.01, airLayerLevel=None, coordinates=None, tol=1e-08, saveMemory=False, directSolver=True)¶ initializes a new forward model. See base class for a description of the arguments.
-
getArguments
(rho)¶ Returns precomputed values shared by
getDefect()
andgetGradient()
.Parameters: rho ( Data
of shape (2,)) – resistivityReturns: Hx, grad(Hx) Return type: tuple
ofData
-
getCoordinateTransformation
()¶ returns the coordinate transformation being used
Return type: CoordinateTransformation
-
getDefect
(rho, Hx, g_Hx)¶ Returns the defect value.
Parameters: - rho (
Data
of shape ()) – a suggestion for resistivity - Hx (
Data
of shape (2,)) – magnetic field - g_Hx (
Data
of shape (2,2)) – gradient of magnetic field
Return type: float
- rho (
-
getDomain
()¶ Returns the domain of the forward model.
Return type: Domain
-
getGradient
(rho, Hx, g_Hx)¶ Returns the gradient of the defect with respect to resistivity.
Parameters: - rho (
Data
of shape ()) – a suggestion for resistivity - Hx (
Data
of shape (2,)) – magnetic field - g_Hx (
Data
of shape (2,2)) – gradient of magnetic field
- rho (
-
getWeightingFactor
(x, wx0, x0, eta)¶ returns the weighting factor
-
setUpPDE
()¶ Return the underlying PDE.
Return type: LinearPDE


Darren Ramsook, Patrick Hosein and Akash Pooransingh
6th International Conference on Internet Science, Perpignan, France
Patrick Hosein and Shiva Ramoudith
6th International Conference on Internet Science, Perpignan, France
Patrick Hosein, Shiva Ramoudith and Kim Mallalieu
6th International Conference on Internet Science, Perpignan, France
Patrick Hosein, Victor Job and Alana Sankar-Ramkarran
International Conference on Optimization and Decision Science, Genova, Italy
Laura Bigram, Patrick Hosein and Jonathan Earle
International Conference on Optimization and Decision Science, Taormina, Italy
Nicholas Chamansingh, Patrick Hosein and Elena Dyer
Triennial Conference of the Association of Asia Pacific Operational Research Societies, Kathmandu, Nepal
Shiva Ramoudith, Patrick Hosein and Kevin Blake-Thomas
Triennial Conference of the Association of Asia Pacific Operational Research Societies, Kathmandu, Nepal
Ramneek, Patrick Hosein and Sungin Jung
6th International Conference on Internet Science, Perpignan, France
Ramneek Sekhon, Patrick Hosein, Woojin Seok and Jaiseung Kwak
19th Asia-Pacific Network Operations and Management Symposium, Seoul, South Korea
Ramneek , P. Hosein, W. Choi and W. Seok
Journal of Advanced Research in Dynamical and Control Systems
Ramneek, P. Hosein, W. Choi and W. Seok
International Conference on High Performance Computing and Simulation, Innsbruck, Austria
Ramneek, P.Hosein, W.Choi, W. Seok
Journal of Communications and Networks
Ramneek, P. Hosein, W. Choi and W. Seok
IEEE International Conference on Advanced Communication Technology, Phoenix Park, South Korea


{% if query_log.state == 3 %}
{% endif %}
Welcome to Data Explorer
You can:
- filter, combine or search datasets using an SQL query
- share an SQL query with your colleagues
- learn how to use Data Explorer


Proficient Animator with +3 years of experience in production environment. Strive in making deadlines ahead of project due dates and the additional ability to work with others and within large teams. Desiring to contribute to the success of a company by going above and beyond expectations and deadlines.
So far worked on a 3D animation movie Wheelie (releasing 2018); Marvel’s Lego Guardians of Galaxy TV series, DVD movie of Matt Hatter Chronicles and Space Racers.
Check My Work


Classes and interfaces
ExceptionInterface¶
The interface for custom exceptions.
« More »
ValidatorInterface¶
A contract for validators
« More »
HttpAdapterInterface¶
The http connection interface for the adapter pattern.
« More »
Strategy¶
An interface for the output strategy pattern.
« More »
HttpRequest¶
An interface for a general http request.
« More »
PolicyInterface¶
A contract for class-to-endpoint mapping.
« More »
FileDoesNotExistException¶
A custom exception thrown when a file does not exist.
« More »
InvalidArgumentException¶
A custom exception thrown when an invalid argument is provided.
« More »
InvalidCredentialsException¶
A custom exception thrown when no valid credential is provided.
« More »
InvalidJsonException¶
A custom exception thrown when an invalid json string is encountered.
« More »
InvalidXmlException¶
A custom exception thrown when an invalid xml string is encountered.
« More »
NoOutputException¶
A custom exception thrown when output is not specified.
« More »
NoProviderException¶
A custom exception thrown when provider is not specified.
« More »
NoResultException¶
A custom exception thrown when result is a failure.
« More »
NotImplementedException¶
A custom exception thrown when functionality not implemented.

« More »
Engine¶
Allows to validate data using validators
« More »
Validator¶
A base class for validators
« More »
RequireAll¶
A validator that verifies a full match against all domain options.
« More »
RequireAtLeast¶
A validator that verifies a match against some domain options.
« More »
FurryBear¶
The main class that glues it all together.
« More »
FurryBearContainer¶
A container with pre-registered services.
« More »
AbstractProvider¶
An abstract presentation of a geocode provider.
« More »
BingMaps¶
Bing Maps geocode provider
« More »
Chain¶
A special provider that iterates over a list of providers until a valid
result is returned.

« More »
Guzzle¶
A HTTP adapter based on Guzzle http client.
« More »
PhrasesEntityPageIterator¶
An iterator over the pages of the result.
« More »
PhrasesPageIterator¶
An iterator over the pages of the result.
« More »
TextPageIterator¶
An iterator over the pages of the result.
« More »
PageIterator¶
An iterator over the pages of the result.
« More »
BillsPageIterator¶
An iterator over the pages of the result.
« More »
PageIterator¶
An iterator over the pages of the result.
« More »
Json¶
Converts an xml error to a more readable format
« More »
Xml¶
Converts an xml error to a more readable format
« More »
JsonToArray¶
Converts the json string returned from the service to an array.
« More »
JsonToObject¶
Converts the json string returned from the service to an object.
« More »
XmlToObject¶
Converts the xml string returned from the service to an object.
« More »
AbstractProvider¶
An abstract provider class that sets up a basic provider.
« More »
SunlightCapitolWords¶
A concrete provider based on Sunlight Foundation Capitol Words API.
« More »
SunlightCongress¶
A concrete provider based on Sunlight Foundation Congress API v3.
« More »
SunlightOpenStates¶
A concrete provider based on Sunlight Foundation Open States API.
« More »
SunlightPoliticalPartyTime¶
A concrete provider based on Sunlight Political Party Time API.
« More »
Buzz¶
A proxy that provides a surrogate for Buzz http client.
« More »
Curl¶
A proxy that provides a surrogate for curl.
« More »
Guzzle¶
A proxy that provides a surrogate for Guzzle http client.
« More »
AbstractResource¶
An abstract presentation of a resource.

« More »
BaseResource¶
A base presentation of SunlightCapitolWords resource.
« More »
FqnPolicy¶
A specific policy for mapping Sunlight Capitol Words resource names to fully
qualified class names.
« More »
Dates¶
This class gives access to Sunlight Capitol Words dates resource.
« More »
Phrases¶
This class gives access to Sunlight Capitol Words phrases resource.
« More »
Text¶
This class gives access to Sunlight Capitol Words text resource.
« More »
BaseResource¶
A base presentation of SunlightCongress resource.
« More »
FqnPolicy¶
A specific policy for mapping Sunlight Congress resource names to fully
qualified class names.
« More »
Bills¶
This class gives access to Sunlight Congress bills resource.
« More »
BillsSearch¶
This class gives access to Sunlight Congress bills/search resource.
« More »
BulkData¶
This class gives access to Sunlight Congress bulk data.
« More »
Committees¶
This class gives access to Sunlight Congress committees resource.
« More »
DistrictsLocate¶
This class gives access to Sunlight Congress districts/locate resource.
« More »
FloorUpdates¶
This class gives access to Sunlight Congress floor_updates resource.
« More »
Hearings¶
This class gives access to Sunlight Congress hearings resource.
« More »
Legislators¶
This class gives access to Sunlight Congress legislators resource.
« More »
LegislatorsLocate¶
This class gives access to Sunlight Congress legislators/locate resource.
« More »
UpcomingBills¶
This class gives access to Sunlight Congress upcoming_bills resource.
« More »
Votes¶
This class gives access to Sunlight Congress votes resource.
« More »
BaseResource¶
A base presentation of Sunlight Open States resource.
« More »
FqnPolicy¶
A specific policy for mapping Sunlight Open States resource names to fully
qualified class names.
« More »
BillDetail¶
This class gives access to Sunlight Open States bill detail resource.
« More »
Bills¶
This class gives access to Sunlight Open States bills resource.
« More »
CommitteeDetail¶
This class gives access to Sunlight Open States committees detail resource.
« More »
Committees¶
This class gives access to Sunlight Open States committees resource.
« More »
DistrictBoundary¶
This class gives access to Sunlight Open States districts boundary resource.
« More »
Districts¶
This class gives access to Sunlight Open States districts resource.
« More »
EventDetail¶
This class gives access to Sunlight Open States events detail resource.
« More »
Events¶
This class gives access to Sunlight Open States events resource.
« More »
GeoLookup¶
This class gives access to Sunlight Open States geo lookup resource.
« More »
LegislatorDetail¶
This class gives access to Sunlight Open States legislators detail resource.
« More »
Legislators¶
This class gives access to Sunlight Open States legislators resource.
« More »
BaseResource¶
A base presentation of Sunlight Political Party Time resource.
« More »
FqnPolicy¶
A specific policy for mapping Sunlight Open States resource names to fully
qualified class names.
« More »
EventDetail¶
This class gives access to Sunlight Political Party Time events detail resource.
« More »
Events¶
This class gives access to Sunlight Political Party Time events resource.
« More »
HostDetail¶
This class gives access to Sunlight Political Party Time hosts detail resource.
« More »
Hosts¶
This class gives access to Sunlight Political Party Time hosts resource.
« More »
LawmakerDetail¶
This class gives access to Sunlight Political Party Time lawmaker detail resource.
« More »
Lawmakers¶
This class gives access to Sunlight Political Party Time lawmakers resource.
« More »
SplClassLoader¶
SplClassLoader implements the autoloader interoperability standard PSR-0.
« More »


It is an on-demand delivery service that connects you to the nearest vegetable peddlers .Veg Vendors aim is to amend the traditional way of people buying groceries to make the local shopping experience more convenient and amicable. We are substituting your visits to the nearby vegetable peddlers with a few taps on the mobile/laptop/computer/tab.


Vlieland is one of the Frisian islands. It is the one east of Texel. The town of Oost Vlieland is on the extreme eastern tip of the island. It is a very attractive town with a popular yacht harbour.
This is no longer a Port of Entry as there is no customs port here.
In the height of the season it is sometimes closed to visitors, who then have to anchor outside.
Beware of the strong tidal currents when entering or leaving the narrow entrance to this harbour. This also causes whirlpools which can catch out the unwary helmsman.
Since the recent renovations, this harbour has good, modern facilities including a resaurant and a small provision store.
Many more provisions can be obtained in the village.
Last updated December 2010.


FloatLessOrEqualsTest.testComparableEqualsFailNoMessage: Float 'valueA'(0.124) is less than or equal to Float 'valueB'(0.124). FloatLessOrEqualsTest.testComparableLessFailMessage: Float 'valueA'(0.123) is less than or equal to Float 'valueB'(0.124). Extra info goes here. FloatLessOrEqualsTest.testComparableEqualsFailMessage: Float 'valueA'(-0.124) is less than or equal to Float 'valueB'(-0.124). Extra info goes here. FloatLessOrEqualsTest.testComparableLessFailNoMessage: Float 'valueA'(-0.123) is less than or equal to Float 'valueB'(0.123).


Getting Started¶
General¶
The main starting point for running simulations with the adpeps package is by loading the module directly via python -m adpeps
.
For both ground-state and excited-state simulations the configuration can be set via configuration .yaml
files.
Each option in the configuration file corresponds to an attribute of the adpeps.ipeps.config
module.
The first argument for the module is the simulation mode (ground-state or excited-state):
python -m adpeps {gs,exci} ...
Note
The input configuration file location can be set via the
CONFIGDIR
variable. If it is not set, the default
input folder will be the examples subfolder of the package
root directory
Note
The output data location can be set via the DATADIR
variable. If it is not set, the default output folder will be
in the simulations subfolder of the package root directory.
Ground states¶
For ground-state simulations, the only required argument is the configuration file.
usage: python -m adpeps gs [-h] config_file
Positional Arguments¶
- config_file
Configuration (.yml) file for the simulation options
Excited states¶
For excited-state simulations, the first argument is again the name of a configuration file (note that the relevant options are different for excited-state simulations), and furthermore the momentum index -p
is required.
The momentum index refers to a point in momentum space \((k_x, k_y)\) defined in a specific path through the Brillouin zone.
The corresponding momentum path can be set via the adpeps.ipeps.config.momentum_path
option.
By default, the ‘Bril1’ path is taken, which follows the cut along high symmetry points \((\pi,0) - (\pi,\pi) - (\pi/2,\pi/2) - (0,0) - (\pi,0) - (\pi/2,\pi/2)\)
usage: python -m adpeps exci [-h] [-p MOMENTUM_IX] [-e] [-i]
config_file
Positional Arguments¶
- config_file
config file of excited-state simulation
Named Arguments¶
- -p, --p_ix
momentum index
- -e, --eval
Prepare excitation base
- -i, --init
Prepare excitation base


Eric's new album "Wynton Marsalis & Eric Clapton Play The Blues - Live From Jazz At Lincoln Center" is available now. Get your copy on: Amazon.com http://amzn.to/n5tAeg iTunes http://wbr.fm/ECblues Or through EC Access, with a one year membership to Eric's Official Fanclub. http://ecaccess.cc/ New York City's premier jazz venue got the blues last April when Wynton Marsalis and Eric Clapton performed together in Rose Theater at Frederick P. Rose Hall, home of Jazz at Lincoln Center for two sold-out shows dedicated to vintage blues. The extraordinary collaboration, billed as Wynton Marsalis & Eric Clapton Play the Blues, paired these musical virtuosos with members of the Jazz at Lincoln Center Orchestra as they brought to life a repertoire of songs selected by Clapton and arranged by Marsalis.


Umar Musa Yar'adua
A selfless leader who put Nigeria on his shoulder
The Life of Umar Musa Yar'adua is as follows:
- 1912 - Umar Musa Yar'adua is born
- 1928 - He gets his education at Katsina College
- 1930 - Musa begins his career in teaching at Katsina Middle School
- 1999 - He serves as the Governor of Katsina state, and he is a member of the People's Democratic Party (PDP) up to 2007
- 2007 - Umar Musa Yar'adua is voted the President of Nigeria
- 2007 - 2010 He does the following amoung others:
- Reduction of Petrol pump price from 75 naira to 65 naira
- Declaration of all his assets setting a template for others to follow
- Approval of the Dredging of River Niger
- Granting of Amnesty to Niger-Delta Militants
- Construction of the Kaduna-Abuja railway
- 2010 - On the 5th of May, Umar Musa Yar'adua dies
More information about Umar Musa Yar'adua can be found here


# -*- coding: utf-8 -*- # # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information regarding copyright ownership. # The ASF licenses this file to You under the Apache License, Version 2.0 # (the "License"); you may not use this file except in compliance with # the License. You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # import functools import itertools import os import platform import re import sys import threading import traceback import types from py4j.clientserver import ClientServer __all__ = [] # type: ignore def print_exec(stream): ei = sys.exc_info() traceback.print_exception(ei[0], ei[1], ei[2], None, stream) [docs]class VersionUtils(object): """ Provides utility method to determine Spark versions with given input string. """ [docs] @staticmethod def majorMinorVersion(sparkVersion): """ Given a Spark version string, return the (major version number, minor version number). E.g., for 2.0.1-SNAPSHOT, return (2, 0). Examples -------- >>> sparkVersion = "2.4.0" >>> VersionUtils.majorMinorVersion(sparkVersion) (2, 4) >>> sparkVersion = "2.3.0-SNAPSHOT" >>> VersionUtils.majorMinorVersion(sparkVersion) (2, 3) """ m = re.search(r'^(\d+)\.(\d+)(\..*)?$', sparkVersion) if m is not None: return (int(m.group(1)), int(m.group(2))) else: raise ValueError("Spark tried to parse '%s' as a Spark" % sparkVersion + " version string, but it could not find the major and minor" + " version numbers.") def fail_on_stopiteration(f): """ Wraps the input function to fail on 'StopIteration' by raising a 'RuntimeError' prevents silent loss of data when 'f' is used in a for loop in Spark code """ def wrapper(*args, **kwargs): try: return f(*args, **kwargs) except StopIteration as exc: raise RuntimeError( "Caught StopIteration thrown from user's code; failing the task", exc ) return wrapper def walk_tb(tb): while tb is not None: yield tb tb = tb.tb_next def try_simplify_traceback(tb): """ Simplify the traceback. It removes the tracebacks in the current package, and only shows the traceback that is related to the thirdparty and user-specified codes. Returns ------- TracebackType or None Simplified traceback instance. It returns None if it fails to simplify. Notes ----- This keeps the tracebacks once it sees they are from a different file even though the following tracebacks are from the current package.  File "/.../pyspark/util.py", line ... ... RuntimeError: ... >>> "pyspark/util.py" in exc_info True If the traceback is simplified with this method, it hides the current package file name: >>> exc_info = None >>> try: ... fail_on_stopiteration(dummy_module.raise_stop_iteration)() ... except Exception as e: ... tb = try_simplify_traceback(sys.exc_info()[-1]) ... e.__cause__ = None ... exc_info = "".join( ... traceback.format_exception( ... type(e), e, try_simplify_traceback(skip_doctest_traceback(tb)))) >>> print(exc_info) # doctest: +NORMALIZE_WHITESPACE, +ELLIPSIS RuntimeError: ... >>> "pyspark/util.py" in exc_info False In the case below, the traceback contains the current package in the middle. In this case, it just hides the top occurrence only. >>> exc_info = None >>> try: ... fail_on_stopiteration(dummy_module.simple_wrapper( ... fail_on_stopiteration(dummy_module.raise_stop_iteration)))() ... except Exception as e: ... tb = sys.exc_info()[-1] ... e.__cause__ = None ... exc_info_a = "".join( ... traceback.format_exception(type(e), e, tb)) ... exc_info_b = "".join( ... traceback.format_exception( ... type(e), e, try_simplify_traceback(skip_doctest_traceback(tb)))) >>> exc_info_a.count("pyspark/util.py") 2 >>> exc_info_b.count("pyspark/util.py") 1 """ if "pypy" in platform.python_implementation().lower(): # Traceback modification is not supported with PyPy in PySpark. return None if sys.version_info[:2] < (3, 7): # Traceback creation is not supported Python < 3.7. # See https://bugs.python.org/issue30579. return None import pyspark root = os.path.dirname(pyspark.__file__) tb_next = None new_tb = None pairs = zip(walk_tb(tb), traceback.extract_tb(tb)) last_seen = [] for cur_tb, cur_frame in pairs: if not cur_frame.filename.startswith(root): # Filter the stacktrace from the PySpark source itself. last_seen = [(cur_tb, cur_frame)] break for cur_tb, cur_frame in reversed(list(itertools.chain(last_seen, pairs))): # Once we have seen the file names outside, don't skip. new_tb = types.TracebackType( tb_next=tb_next, tb_frame=cur_tb.tb_frame, tb_lasti=cur_tb.tb_frame.f_lasti, tb_lineno=cur_tb.tb_frame.f_lineno if cur_tb.tb_frame.f_lineno is not None else -1) tb_next = new_tb return new_tb def _print_missing_jar(lib_name, pkg_name, jar_name, spark_version): print(""" ________________________________________________________________________________________________ Spark %(lib_name)s libraries not found in class path. Try one of the following. 1. Include the %(lib_name)s library and its dependencies with in the spark-submit command as $ bin/spark-submit --packages org.apache.spark:spark-%(pkg_name)s:%(spark_version)s ... 2. Download the JAR of the artifact from Maven Central http://search.maven.org/, Group Id = org.apache.spark, Artifact Id = spark-%(jar_name)s, Version = %(spark_version)s. Then, include the jar in the spark-submit command as $ bin/spark-submit --jars <spark-%(jar_name)s.jar> ... ________________________________________________________________________________________________ """ % { "lib_name": lib_name, "pkg_name": pkg_name, "jar_name": jar_name, "spark_version": spark_version }) def _parse_memory(s): """ Parse a memory string in the format supported by Java (e.g. 1g, 200m) and return the value in MiB Examples -------- >>> _parse_memory("256m") 256 >>> _parse_memory("2g") 2048 """ units = {'g': 1024, 'm': 1, 't': 1 << 20, 'k': 1.0 / 1024} if s[-1].lower() not in units: raise ValueError("invalid format: " + s) return int(float(s[:-1]) * units[s[-1].lower()]) [docs]def inheritable_thread_target(f): """ Return thread target wrapper which is recommended to be used in PySpark when the pinned thread mode is enabled. The wrapper function, before calling original thread target, it inherits the inheritable properties specific to JVM thread such as ``InheritableThreadLocal``. Also, note that pinned thread mode does not close the connection from Python to JVM when the thread is finished in the Python side. With this wrapper, Python garbage-collects the Python thread instance and also closes the connection which finishes JVM thread correctly. When the pinned thread mode is off, it return the original ``f``. .. versionadded:: 3.2.0 Parameters ---------- f : function the original thread target. Notes ----- This API is experimental. It is important to know that it captures the local properties when you decorate it whereas :class:`InheritableThread` captures when the thread is started. Therefore, it is encouraged to decorate it when you want to capture the local properties. For example, the local properties from the current Spark context is captured when you define a function here instead of the invocation: >>> @inheritable_thread_target ... def target_func(): ... pass # your codes. If you have any updates on local properties afterwards, it would not be reflected to the Spark context in ``target_func()``. The example below mimics the behavior of JVM threads as close as possible: >>> Thread(target=inheritable_thread_target(target_func)).start() # doctest: +SKIP """ from pyspark import SparkContext if isinstance(SparkContext._gateway, ClientServer): # Here's when the pinned-thread mode (PYSPARK_PIN_THREAD) is on. # NOTICE the internal difference vs `InheritableThread`. `InheritableThread` # copies local properties when the thread starts but `inheritable_thread_target` # copies when the function is wrapped. properties = SparkContext._active_spark_context._jsc.sc().getLocalProperties().clone() @functools.wraps(f) def wrapped(*args, **kwargs): # Set local properties in child thread. SparkContext._active_spark_context._jsc.sc().setLocalProperties(properties) return f(*args, **kwargs) return wrapped else: return f [docs]class InheritableThread(threading.Thread): """ Thread that is recommended to be used in PySpark instead of :class:`threading.Thread` when the pinned thread mode is enabled. The usage of this class is exactly same as :class:`threading.Thread` but correctly inherits the inheritable properties specific to JVM thread such as ``InheritableThreadLocal``. Also, note that pinned thread mode does not close the connection from Python to JVM when the thread is finished in the Python side. With this class, Python garbage-collects the Python thread instance and also closes the connection which finishes JVM thread correctly. When the pinned thread mode is off, this works as :class:`threading.Thread`. .. versionadded:: 3.1.0 Notes ----- This API is experimental. """ def __init__(self, target, *args, **kwargs): from pyspark import SparkContext if isinstance(SparkContext._gateway, ClientServer): # Here's when the pinned-thread mode (PYSPARK_PIN_THREAD) is on. def copy_local_properties(*a, **k): # self._props is set before starting the thread to match the behavior with JVM. assert hasattr(self, "_props") SparkContext._active_spark_context._jsc.sc().setLocalProperties(self._props) return target(*a, **k) super(InheritableThread, self).__init__( target=copy_local_properties, *args, **kwargs) else: super(InheritableThread, self).__init__(target=target, *args, **kwargs) def start(self, *args, **kwargs): from pyspark import SparkContext if isinstance(SparkContext._gateway, ClientServer): # Here's when the pinned-thread mode (PYSPARK_PIN_THREAD) is on. # Local property copy should happen in Thread.start to mimic JVM's behavior. self._props = SparkContext._active_spark_context._jsc.sc().getLocalProperties().clone() return super(InheritableThread, self).start(*args, **kwargs) if __name__ == "__main__": if "pypy" not in platform.python_implementation().lower() and sys.version_info[:2] >= (3, 7): import doctest import pyspark.util from pyspark.context import SparkContext globs = pyspark.util.__dict__.copy() globs['sc'] = SparkContext('local[4]', 'PythonTest') (failure_count, test_count) = doctest.testmod(pyspark.util, globs=globs) globs['sc'].stop() if failure_count: sys.exit(-1)


{% extends "loginportal.html" %} {% block title %} Customer Register Portal {% endblock %} {% block form %}
Username
Username aldready exists.
Password
Confirm Password
Passwords dont match.
Aldready have an account. Login instead.


System Architect Picture "Classification In Version"
Parent Diagram:
Classification Element
(OMT Object Model)


Vector ClassVector Construction
Vector v; // Empty vector. Vector v({1,3,5,7,9}); // Vector of length 5, with initial // values 1,3,5,7,9 Vector v(K); // Vector of length K, initialed by zeros. Vector v(K, buffer); // Vector of length K, initialized from // buffer pointed by double pointer buffer. Vector v(Range(0, 10, 2) // Vector of even numbers from 0 to 8. Vector v(v2); // Copy constructors Vector v = v2; Special Vectors
Vector v = Vector::Ones(K); // Vector of length K, all initialized to one. Vector v = Vector::Zeros(K); // Vector of length K, all initialized to zero Size Operations
size_t s = v.size(); // returns number. elements of v. bool b = v.empty(); // returns true if v has no elements. v.resize(new_size); // Resizes the vector v. // If new size is smaller than current size, // stored data is cropped. Otherwise, some garbage // values are appended at the end. Value Access
double d = v(i) // get the i^th element double d = v[i] // get the i^th element v(i) = 7; // set the i^th element v[i] = 7; // set the i^th element double d = v.first(); // set & get first element v.first() = 6; double d = v.first(); // set & get last element v.last() = 6; double d = 5; // append value to the end v.push_back(d); v.append(d); v.append(v2); // append elements from v2 to the end of v v.pop_back(d); // remove last element double *buffer = v.data(); // get pointer to the underlying data storage const double *buffer = v.data(); // get constant pointer to the underlying // data storage Algebra
v = 5; // sets all elements to given scalar v += 5; // Addition, subtraction, multiplication and v -= 5; // division by a double scalar (in-place) v *= 5; v /= 5; v += v2 // Element-wise addition, subtraction, multiplication v -= v2 // and division of vectors. (in place) v *= v2 v /= v2 Vector w = v + 5; // Addition, subtraction, multiplication and Vector w = v - 5; // division by scalar. Vector w = v * 5; Vector w = v / 5; Vector w = v + v2; // Element-wise addition, subtraction, Vector w = v - v2; // multiplication and division. Vector w = v * v2; Vector w = v / v2; double d = Dot(v1,v2); // Dot product of two vectors. Comparisons
bool b = v.equals(v2); // true if v & v2 have equal lengths, and // v[i] == v2[i] for each i Vector v2 = v == d; // Compares vector v with double d. Vector v2 = v > d; // Returns binary vector v2. Vector v2 = v < d; // v2[i] == 1 only if "v[i] COND d" is true. Vector v2 = v == v3; // Compares two vectors element-wise Vector v2 = v < v3; Vector v2 = v > v3; bool b = all(v); // True if binary vector v is all 1s. bool b = any(v); // True if binary vector v has at least one 1. Vector v2 = find(v); // Returns indices of the binary vector v, that are 1. Save and Load
std::cout << v; // Prints vector to stream cout. v.saveTxt(filename) // Saves vector to text file with precision of 6. Vector v2 = Vector::loadTxt(filename) // Creates a new vector from file. Utilities
double d = min(v); // Minimum element. double d = max(v); // Maximum element. double d = sum(v); // Sum of elements. double d = mean(v); // Mean of elements. double d = var(v); // Variance of elements. double d = stdev(v); // Standard deviation of elements. Vector v2 = abs(v); // Absolute value of elements. Vector v2 = round(v); // Round to nearest integer. Vector v2 = pow(v, p); // p^th power of each element. Vector v2 = log(v); // Logarithm. Vector v2 = exp(v); // Exponentiation. Vector v2 = psi(v); // DiGamma function. Vector v2 = lgamma(v); // Log Gamma function. Vector v2 = normalize(v); // Normalization. Vector v2 = normalizeExp(v); // Safe normalize(exp(v)) double d = logSumExp(v); // Safe log(sum((exp(v)) double d = kl_div(v,v2); // Kullback-Leibler Divergence between v and v2. Vector v2 = slice(v, Range(start, stop, step)) // Creates a new vector from // a slice of v. |


CONSOLEHELPER
Section: Maintenance Commands (8)Updated: 18 March 1999
Index Return to Main Contents
NAME
consolehelper - A wrapper that helps console users run system programsSYNOPSIS
progname [ options ]DESCRIPTION
consolehelper is a tool that makes it easy for console users to run system programs, doing authentication via PAM (which can be set up to trust all console users or to ask for a password at the system administrator's discretion). When possible, the authentication is done graphically; otherwise, it is done within the text console from which consolehelper was started.It is intended to be completely transparent. This means that the user will never run the consolehelper program directly. Instead, programs like /sbin/shutdown are paired with a link from /usr/bin/shutdown to /usr/bin/consolehelper. Then when non-root users (specifically, users without /sbin in their path, or /sbin after /usr/bin) call the "shutdown" program, consolehelper will be invoked to authenticate the action and then invoke /sbin/shutdown. (consolehelper itself has no priviledges; it calls the userhelper(8) program do the real work.)
consolehelper requires that a PAM configuration for every managed program exist. So to make /sbin/foo or /usr/sbin/foo managed, you need to create a link from /usr/bin/foo to /usr/bin/consolehelper and create the file /etc/pam.d/foo, normally using the pam_console(8) PAM module.
OPTIONS
This program has no command line options of its own; it passes all command line options on to the program it is calling.SEE ALSO
userhelper(8)AUTHOR
Michael K. Johnson<EMAIL_ADDRESS>Index
This document was created by man2html, using the manual pages.
Time: 05:34:25 GMT, December 24, 2015


{% extends "base.html" %} {% block title %}500 - Internal Server Error | SoCraTes Conference{% endblock %} {% block container %}
We messed up! Sorry!
We've recorded this error and will fix it asap.