HTTP is the language used to communicate between web browsers and servers developed by Tim Berners-Lee in 1989. It is the foundation of data communication for the World Wide Web. HTTP functions as a request-response protocol in the client-serving computing model. For example, a web browser may be the client and an application hosting a website may be the server. HTTP is a client-server protocol meaning that requests are sent by one entity, the user-agent, which is usually the web browser. A user-agent is any tool that acts on behalf of the user.
The image to the right provides a basic illustration of how HTTP works.
HTTPS is an extension of HTTP used for secure communication over a computer network and is used widely on the internet. The communication protocl is encrypted using Transport Layer Security (TLS) or Secure Sockets Layer (SSL). HTTPS allows for authentication of an accessed website, where exchanged data in transit remains protected. It protects against cyber attacks. Web browsers are aware of which HTTPS websites to trust based on certificate authorities within software. Companies such as banks, e-commerce, and any website that require you to put in personal information, such as log in username and password, all user HTTPS to keep their users information protected.
The image to the right provides an illustration of the difference between HTTP and HTTPS. When a website is secure, you will see a lock next to HTTPS.


TimeCircle examples
Time until 2014
Counting down 15 minutes (900 seconds)
Start Timer
Stop Timer
Time since page was opened
Fade in
Fade out


Toggle navigation
Menu
mmMap
Calendars
Download
Features
Contact
Subscribe to Calendar Events
: O' Miami
Subscribe to Calendar Events
: The Wynwood Yard


You have encountered an error, check below for futher information
Activation Error
The link you used is not valid, it has either expired or is incorrect. Try requesting for another mail with the form below. You can either use the email you used before or try a new one.


In this period
{{ player?.name || 'Player' }} has played as every faction
In this period
{{ player?.name || 'Player' }} has not played as
{{ faction.name }}{{ i < playerInsights.neverPlayedFactions.length -2 ? ',' :
i === playerInsights.neverPlayedFactions.length -2 ? ' or' : '' }}
In this period
{{ player?.name || 'Player' }} has played as every agenda
In this period
{{ player?.name || 'Player' }} has not played as
{{ agenda.title }}{{ i < playerInsights.neverPlayedAgendas.length -2 ? ',' :
i === playerInsights.neverPlayedAgendas.length -2 ? ' or' : '' }}


Below are 3 instances of the jQuery Parallax Slider Plug-in that demonstrate some of its features.
Please download the source files instead of hot-linking them.


{% extends "base.html" %} {% block title %}Topics{% endblock %} {% block content %}
Your project managers (2 of which are Certified ScrumMasters) will define Agile and present the Agile Manifesto. There will be a video on "Scrum in less than 120 seconds" and a viral video "Sh*t Bad Scrum Masters Say" by Adam Weisbart. The PM's will also review the Global Scrum Gathering they all attended in Las Vegas back in May. There is a 5 minute summary video of the opening keynote speaker, Jeff Sutherland, the creator of Scrum, on "The Future of Work" and the closing keynote speaker, Alistair Cockburn, on Core Scrum and Barnacles. We will discuss the concept of Open Space from the Scrum Gathering and end with a participation exercise we're calling "Candy Crush: Waterfall vs. Agile".
Will be an introductory talk with an aim of teaching people the concepts and terminology of DI. I will be going over the various forms of DI and the pros and cons of each one so that developers can know when and how to use DI.
Cloud Computing Explained
Windows Azure Platform Overview
Will be going through the very basics of MongoDB client. From converting SQL commands to Mongo commands, to setting up your php to use MongoDB client. I will be going through examples as well as best practices and some gotchas that I discovered along the way. If time permits I will go through some other tools that can be used such as table export.
"No user interface is the Best user interface!" said Giri Sow, the next-gen AI from John's smart phone.
Wait. What? Only a few years ago we were scrambling to get ahead in the mobile world & now we're faced with another paradigm shift: the vanishing interface and the AI's that make it possible. In this discussion, Ryan will present a mix of ideas from SXSW 2013 which cover topics on how to think "No UI", why that's awesome for the user, and where the next generation of AIs like Siri will take us. Most importantly, we'll talk about how these concepts apply to our work in a web world from a product and programming perspective.
This interactive discussion will feature some group discussion and light thought-experiments.
#noUImyAI
Is your code readable? Testable? Maintainable? If you answered no to any or all of these questions Object Calisthenics can help. In this session we will learn about programming exercises, formalized as a set of 9* "rules", know as Object Calisthenics. By trying to follow these "rules" as much as possible, you will naturally change how you write code. If you already write code that is readable, testable, and maintainable, then these rules will help you write code that is more readable, more testable and more maintainable.
PhpUnit is a tool for writing Unit Tests against PHP code. We will start with the basics of PhpUnit and how to use it. From there we will have some example of Unit Tests and how to best utilize them. Test Driven development and adding Unit Tests to legacy applications will also be touched on.
TBA
This will show a very basic installation of PHP + Oracle + Apache on a Ubuntu build. Since I can't override my local computer, I will be using a VM to go through it. My plan is to show how to install Apache, basics of the Apache on ubuntu. Then show how to install php and set that up. I will *attempt* to install oracle or at least give a very basic overview of how to install it if time permits. Most likely I will show setup instructions but use a vm with Oracle.
How many times have we released code to production that simply doesn’t run because of environmental differences? How many conditions are in our code to run things differently in Windows? Using virtualization, Vagrant makes it easy to create a consistent development environment whether you prefer to code in Mac, Windows, or Linux. This talk covers the basics of how to use Vagrant, as well as how to provision a custom environment.
With the To The Cloud project, we could all deal with some more information about virtualization and cloud-hosted projects. This talk would contain information on what the basic requirements of a portable cloud application are, how to deploy and test a cloud app, and various products (Vagrant, docker, puppet/chef/saltstack, ...) that can play an integral role in any cloud environment to remove the mysticism around the cloud.
If you have any questions please feel free to email us for more details.


Family Seeks Justice For Simba Coach Bus Driver Illegally Detained In South Sudan (Photos)
by Mercy AumaA family is seeking help over their kin, Ashford Mwangi Mburu, a driver who has allegedly been illegally detained in South Sudan.
The family claims that all their efforts to intervene and have their brother brought back home have proved futile, hence resorting to seek help from President, Uhuru Kenyatta.
Through a Facebook post dubbed a petition to the President, the kin recounts the events that led to the detention, stating that he is in a bad state and even worse conditions.
The letter states that the victim Ashford Mwangi was a driver with Simba Coach Bus Company and was involved in an accident on March 18, 2019 while on duty in South Sudan.
Read Also: Family Seeking Justice For Daughter Murdered By Her IEBC Official Boyfriend.
Following the accident, Mwangi was detained for 21 days and later released and allowed to drive the damaged bus to Nairobi but his documents were ceased.
However, according to the post, the bus company is said to have arranged for his re-arrest when he went back in July for the mention of the case and has since been held illegally, without any formal communication.
The author of the post, Peter Mwangi who is believed to be the victim’s father stated that in August, he sought help from the Foreign Office in Nairobi but it was all in vain as he was sent away five times and told to write to the PS and the bus company with no response since.
Read Also: Carnivore Stampede Victim’s Family Still Seeking Justice Years After The Death Of Son Mark Karuu
According to Peter Mwangi, the bus company in question Simba Coach has twisted the accident story to their liking and hence impossible to find justice for their son.
The family has stated that the victim’s mother has been saddened by the matter and is in a bad condition following her heart condition, and might likely succumb due to the stress and inability to see her son.


Github Compare
Home
Github Finder
Github Profile Comparison
"First solve the problem
then write the code"


---
layout: single
title: "Shiny Youtube"
date: 2019-10-31
tags:
- App
- plotly
---
Please click here to view the app
Introduction:
In the year 2005, the company YouTube was founded, and from hence fourth hours, if not days, of people's lives have been lost. What has drawn us to watch endless cat videos, while sitting on the toilet to escaping the prying of our bosses? When did watching people play video games become more exciting than playing them? YouTube has taught people how to build decks, change a flat tire, and, most importantly, that the moon landing was fake. What drives us to endlessly click through these videos, and does this data tell us anything about ourselves?
Objective:
The purpose of this app is to provide users the ability to explore and analyze YouTube's most trending videos across the world. The data set used for this analysis was obtained through Kaggel, and a link to this page can be found here. Each record within in the dataset is a daily record of YouTube's top trending videos across the world from early 2017 to late 2018. YouTube calculates trending videos through a combination of views, shares, comments, and likes.
Breakdown:
This app is broken into three parts: introduction, dataset, and analysis. Part one, which you are currently reading is a breakdown of the app. Part two, is a user interface which allows the user to search through the dataset, watch the videos, and read their descriptions. Part three allows the user to build various graphs to analyze and interpret the results from the dataset.


SOMMERSBY A film review by Lewis Butler Copyright 1993 Lewis Butler
SOMMERSBY is a remake of a wonderful French movie called THE RETURN OF MARTIN GUERRE, which, in turn, is based on court transcripts from the 16th Century in France. THE RETURN OF MARTIN GUERRE was the first movie I saw with Gerard Depardieu, and it is well worth seeing. However, I am not sure if it is available on video or not.
The basic story involves a man (Richard Gere) who returns from the Civil War claiming to be Jack Sommersby. It quickly becomes rather obvious that he is *not* Jack, but, unlike MARTIN GUERRE, that isn't really the point. The point revolves around Laurel Sommersby (Jodie Foster) and her relationship with this man who refuses to acknowledge that he is not Jack Sommersby.
What we get is a wonderful interaction between Gere and Foster, an involving plot, and a perfectly executed ending. No Hollywood balderdash, just honest storytelling. Those of you who saw the original are in for quite a ride, since the movie does not wind up at all like the original.
Foster is magnificent, as always. Her accent is absolute perfection again, and in this regard she is beginning to remind me very much of Meryl Streep. Foster has an uncanny ability to metamorphose into anything imaginable. I'm convinced she could bring dramatic flair to something as empty as Judy Jetson.
Gere turns in what I think is his best performance, though I am not familiar with all of his films. There is an intensity in him that is never quite completely hidden, and a slick charm that is disarming and not at all offensive.
The courtroom scene with Gere and Foster would be worth sitting through an agonizingly bad movie in itself, the tension in Foster as Gere questions her is a perfectly executed balance routine. Fortunately, the entire movie is not terrible, but rather quite charming.
I heartily recommend this movie, and if the Oscars have a good memory, we may see at least a nomination for Foster out of this. I wouldn't be surprised to see Gere gain some respectability from this role, and I think it would be well deserved.
Rating: +3 (-4 to +4)
Recommendation: See THE RETURN OF MARTIN GUERRE, and possibly read the book.
--<EMAIL_ADDRESS>.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Class Main
Class Main
Main abstract class for all booking services.
Direct known subclasses
SmsOrange\Cruise, SmsOrange\Cruise\CostaCruisesWebservice, SmsOrange\Cruise\ManualCruisesWebservice
protected
|
|
final protected
string
|
#
getApiMethod( string $serviceName, string $callerMethod )
Returns an API method mapped to the current action. |
final protected
Unirest\Response
|
#
executeRequest( string $url, string $method, array $body )
Executes a HTTP Request using the Unirest library (http://unirest.io) |
protected
|
$config
|
|
protected
array
|
$headers
|
#
[]
|


| txhousing {ggplot2} | R Documentation |
Information about the housing market in Texas provided by the TAMU real estate center, https://www.recenter.tamu.edu/.
txhousing
A data frame with 8602 observations and 9 variables:
Name of multiple listing service (MLS) area
Date
Number of sales
Total value of sales
Median sale price
Total active listings
"Months inventory": amount of time it would take to sell all current listings at current pace of sales.


Dashboard
Employees
Logout
Dashboard
Overview
Employee Table
Employee Id
First Name
Last Name
Address


About
Hi there! This page is included as an example. Feel free to customize it for your own use upon downloading. Carry on!
About BlackDoc Theme
Some relevant information about this project:
- Built for Jekyll
- Theme based on Poole, the Jekyll butler, and the Hyde theme
- Ideal for sites requiring master-detail layout such as documentation, cheatsheets, lyrics, notes, etc.
- Need a beautiful color scheme for black background? Then you will love BlackDoc theme.


As we have seen in the previous chapter, backward chaining systems are good for solving structured selection types of problems. The Birds system was a good example; however it made the assumption that all information was either absolutely true, or absolutely false. In the real world, there is often uncertainty associated with the rules of thumb an expert uses, as well as the data supplied by the user.
For example, in the Birds system the user might have spotted an albatross at dusk and not been able to clearly tell if it was white or dark colored. An expert system should be able to handle this situation and report that the bird might have been either a laysan or black footed albatross.
The rules too might have uncertainty associated with them. For example a mottled brown duck might only identify a mallard with 80% certainty.
This chapter will describe an expert system shell called Clam which supports backward chaining with uncertainty. The use of uncertainty changes the inference process from that provided by pure Prolog, so Clam has its own rule format and inference engine.
The most common scheme for dealing with uncertainty is to assign a certainty factor to each piece of information in the system. The inference engine automatically updates and maintains the certainty factors as the inference proceeds.
Let's first look at an example using Clam. The certainty factors (preceded by cf) are integers from -100 for definitely false, to +100 for definitely true.
The following is a small knowledge base in Clam which is designed to diagnose a car which will not start. It illustrates some of the behavior of one scheme for handling uncertainty.
goal problem.
rule 1
if not
turn_over and
battery_bad
then problem is battery.
rule 2
if lights_weak
then battery_bad cf 50.
rule 3
if radio_weak
then battery_bad cf 50.
rule 4
if turn_over
and
smell_gas
then problem is flooded cf 80.
rule 5
if turn_over
and
gas_gauge is empty
then problem is out_of_gas cf 90.
rule 6
if turn_over
and
gas_gauge is low
then problem is out_of_gas cf 30.
ask turn_over
menu (yes no)
prompt 'Does the engine turn over?'.
ask lights_weak
menu (yes no)
prompt 'Are the lights weak?'.
ask radio_weak
menu (yes no)
prompt 'Is the radio weak?'.
ask smell_gas
menu (yes no)
prompt 'Do you smell gas?'.
ask gas_gauge
menu (empty low full)
prompt 'What does the gas gauge say?'.
The inference uses backward chaining similar to pure Prolog. The goal states that a value for the attribute problem is to be found. Rule 1 will cause the sub-goal of bad_battery to be pursued, just as in Prolog.
The rule format also allows for the addition of certainty factors. For example rules 5 and 6 reflect the varying degrees of certainty with which one can conclude that the car is out of gas. The uncertainty arises from the inherent uncertainty in gas gauges. Rules 2 and 3 both provide evidence that the battery is bad, but neither one is conclusive.
What follows is a sample dialog of a consultation with the Car expert system.
consult, restart, load, list, trace, how, exit
:consult
Does the engine turn over?
: yes
Do you smell gas?
: yes
What does the gas gauge say?
empty
low
full
: empty
problem-out_of_gas-cf-90
problem-flooded-cf-80
done with problem
Notice, that unlike Prolog, the inference does not stop after having found one possible value for problem. It finds all of the reasonable problems and reports the certainty to which they are known. As can be seen, these certainty factors are not probability values, but simply give some degree of weight to each answer.
The following dialog shows how the user's uncertainty might be entered into the system. The differences from the previous dialog are shown in bold.
:consult
Does the engine turn over?
: yes
Do you smell gas?
: yes cf 50
What does the gas gauge say?
empty
low
full
: empty
problem-out_of_gas-cf-90
problem-flooded-cf-40
done with problem
Notice in this case that the user was only certain to a degree of 50 that there was a gas smell. This results in the system only being half as sure that the problem is flooded.
Finally consider the following consultation which shows how the system combines evidence for a bad battery. Remember that there were two rules which both concluded the battery was weak with a certainty factor of 50.
:consult
Does the engine turn over?
: no
Are the lights weak?
: yes
Is the radio weak?
: yes
problem-battery-cf-75
done with problem
In this case the system combined the two rules to determine that the battery was weak with certainty factor 75. This propagated straight through rule 1 and became the certainty factor for problem battery.
There are various ways in which the certainty factors can be implemented, and how they are propagated through the system, but they all have to deal with the same basic situations:
• rules whose conclusions are uncertain;
• rules whose premises are uncertain;
• user entered data which is uncertain;
• combining uncertain premises with uncertain conclusions;
• updating uncertain working storage data with new, also uncertain information;
• establishing a threshold of uncertainty for when a premise is considered known.
Clam uses the certainty factor scheme which was developed for MYCIN, one of the earliest expert systems used to diagnose bacterial infections. Many commercial expert system shells today use this same scheme.
The basic MYCIN certainty factors (CFs) were designed to produce results that seemed intuitively correct to the experts. Others have argued for factors that are based more on probability theory and still others have experimented with more complex schemes designed to better model the real world. The MYCIN factors, however, do a reasonable job of modeling for many applications with uncertain information.
We have seen from the example how certainty information is added to the rules in the then clause. We have also seen how the user can specify CFs with input data. These are the only two ways uncertainty gets into the system.
Uncertainty associated with a particular run of the system is kept in working storage. Every time a value for an attribute is determined by a rule or a user interaction, the system saves that attribute value pair and associated CF in working storage.
The CFs in the conclusion of the rule are based on the assumption that the premise is known with a CF of 100. That is, if the conclusion has a CF of 80 and the premise is known to CF 100, then the fact which is stored in working storage has a CF of 80. For example, if working storage contained:
turn_over cf 100
smell_gas cf 100
then a firing of rule 4
rule 4
if turn_over and
smell_gas
then problem is flooded cf 80
would result in the following fact being added to working storage:
problem flooded cf 80
However, it is unlikely that a premise is perfectly known. The system needs a means for determining the CF of the premise. The algorithm used is a simple one. The CF for the premise is equal to the minimum CF of the individual sub goals in the premise. If working storage contained:
turn_over cf 80
smell_gas cf 50
then the premise of rule 4 would be known with CF 50, the minimum of the two.
When the premise of a rule is uncertain due to uncertain facts, and the conclusion is uncertain due to the specification in the rule, then the following formula is used to compute the adjusted certainty factor of the conclusion:
CF = RuleCF * PremiseCF / 100.
Given the above working storage and this formula, the result of a firing of rule 4 would be:
problem is flooded cf 40
The resulting CF has been appropriately reduced by the uncertain premise. The premise had a certainty factor of 50, and the conclusion a certainty factor of 80, thus yielding an adjusted conclusion CF of 40.
A threshold value for a premise is needed to prevent all of the rules from firing. The number 20 is used as a minimum CF necessary to consider a rule for firing. This means if working storage had:
turn_over cf 80
smell_gas cf 15
Then rule 4 would not fire due to the low CF associated with the premise.
Next consider the case where there is more than one rule which supports a given conclusion. In this case each of the rules might fire and contribute to the CF of the resulting fact. If a rule fires supporting a conclusion, and that conclusion is already represented in working memory by a fact, then the following formulae are used to compute the new CF associated with the fact. X and Y are the CFs of the existing fact and rule conclusion.
CF(X, Y) = X + Y(100 - X)/100. X, Y both > 0
CF(X, Y) = X + Y/1 - min(|X|, |Y|). one of X, Y < 0
CF(X, Y) = -CF(-X, -Y). X, Y both < 0
For example, both rules 2 and 3 provide evidence for battery_bad.
rule 2
if lights_weak
then battery_bad cf 50.
rule 3
if radio_weak
then battery_bad cf 50.
Assume the following facts are in working storage:
lights_weak cf 100
radio_weak cf 100
A firing of rule 2 would then add the following fact:
battery_bad cf 50
Next rule 3 would fire, also concluding battery_bad cf 50. However there already is a battery_bad fact in working storage so rule 3 updates the existing fact with the new conclusion using the formulae above. This results in working storage being changed to:
battery_bad cf 75
This case most clearly shows why a new inference engine was needed for Clam. When trying to prove a conclusion for which the CF is less than 100, we want to gather all of the evidence both for and against that conclusion and combine it. Prolog's inference engine will only look at a single rule at a time, and succeed or fail based on it.
Since we are writing our own inference engine, we can design our own internal rule format as well. (We will use something easier to read for the user.) It has at least two arguments, one for the IF or left hand side (LHS) which contains the premises, and one for the THEN or right hand side (RHS) which contains the conclusion. It is also useful to keep a third argument for a rule number or name. The overall structure looks like:
rule(Name, LHS, RHS).
The name will be a simple atom identifying the rule. The LHS and RHS must hold the rest of the rule. Typically in expert systems, a rule is read LHS implies RHS. This is backwards from a Prolog rule which can be thought of as being written RHS :- LHS, or RHS is implied by LHS. That is the RHS (conclusion) is written on the left of the rule, and the LHS (premises) is written on the right.
Since we will be backward chaining, and each rule will be used to prove or disprove some bit of information, the RHS contains one goal pattern, and its associated CF. This is:
rhs(Goal, CF)
The LHS can have many sub-goals which are used to prove or disprove the RHS :
lhs(GoalList)
where GoalList is a list of goals.
The next bit of design has to do with the actual format of the goals themselves. Various levels of sophistication can be added to these goals, but for now we will use the simplest form, which is attribute-value pairs. For example, gas_gauge is an attribute, and low is a value. Other attributes have simple yes-no values, such as smell_gas. An attribute-value pair will look like:
av(Attribute, Value)
where Attribute and Value are simple atoms. The entire rule structure looks like:
rule(Name,
lhs( [av(A1, V1), av(A2, V2), ....] ),
rhs( av(Attr, Val), CF) ).
Internally, rule 5 looks like:
rule(5,
lhs( [av(turns_over, yes), av(gas_gauge, empty)] ),
rhs( av(problem, flooded), 80) ).
This rule format is certainly not easy to read, but it makes the structure clear for programming the inference engine. There are two ways to generate more readable rules for the user. One is to use operator definitions. The other is to use Prolog's language handling ability to parse our own rule format. The built-in definite clause grammar (DCG) of most Prologs is excellent for this purpose. Later in this chapter we will use DCG to create a clean user interface to the rules. The forward chaining system in a later chapter uses the operator definition approach.
Now that we have a format for rules, we can write our own inference engine to deal with those rules. Let's summarize the desired behavior:
• combine certainty factors as indicated previously;
• maintain working storage information that is updated as new evidence is acquired;
• find all information about a particular attribute when it is asked for, and put that information in working storage.
The major predicates of the inference engine are shown in figure 3.1. They are described in detail in the rest of this section.
Figure 3.1 Major predicates of Clam inference engine
Let's first decide on the working storage format. It will simply contain the known facts about attribute-value pairs. We will use the Prolog database for them and store them as:
fact (av(A, V), CF).
We want to start the inference by asking for the value of a goal. In the case of the Car expert system we want to find the value of the attribute problem. The main predicate that does inferencing will be findgoal/2. In the Car expert system it could be called from an interpreter with the following query:
?- findgoal( av(problem, X), CF).
The findgoal/2 predicate has to deal with three distinct cases:
• the attribute -value is already known;
• there are rules to deduce the attribute -value;
• we must ask the user.
The system can be designed to automatically ask the user if there are no rules, or it can be designed to force the knowledge engineer to declare which attribute values will be supplied by the user. The latter approach makes the knowledge base for the expert system more explicit, and also provides the opportunity to add more information controlling the dialog with the user. This might be in the form of clearer prompts, and/or input validation criteria.
We can define a new predicate askable/2 that tells which attributes should be retrieved from the user, and the prompt to use. For example:
askable(live, 'Where does it live?').
With this new information we can now write findgoal.
The first rule covers the case where the information is in working storage. It was asserted so we know all known values of the attribute have been found. Therefor we cut so no other clauses are tried.
findgoal(
av(Attr, Val), CF) :-
fact( av(Attr, Val), CF),
!.
The next rule covers the case where there is no known information, and the attribute is askable. In this case we simply ask.
findgoal(av(Attr,
Val), CF) :-
not fact(av(Attr, _), _),
askable(Attr, Prompt),
query_user(Attr, Prompt),
!,
findgoal(av(Attr, Val), CF).
The query_user predicate prompts the user for a value and CF and then asserts it as a fact. The recursive call to findgoal will now pick up this fact.
query_user(Attr,
Prompt) :-
write(Prompt),
read(Val),
read(CF),
asserta( fact(av(Attr, Val), CF)).
The final rule of findgoal covers the interesting case of using other rules. Remember that the inferencing is going to require looking for all rules which provide support for values for the sought attribute, and combining the CFs from them. This is done by calling fg, which uses a repeat fail loop to continue to find rules whose RHS conclude a value for the attribute. The process stops when the attribute is known with a CF of 100, or all the rules have been tried.
findgoal(Goal,
CurCF) :-
fg(Goal, CurCF).
fg(Goal, CurCF)
:-
rule(N, lhs(IfList), rhs(Goal, CF)),
prove(IfList, Tally),
adjust(CF, Tally, NewCF),
update(Goal, NewCF, CurCF),
CurCF == 100, !.
fg(Goal, CF) :- fact(Goal, CF).
The three new predicates called in fg are as follows:
prove - prove the LHS premise and find its CF;
adjust - combine the LHS CF with the RHS CF;
update - update existing working storage values with the new conclusion.
This is the guts of the inferencing process for the new inference engine. First it finds a rule whose RHS matches the pattern of the goal. It then feeds the LHS of that rule into prove which succeeds if the LHS can be proved. The prove predicate returns the combined CF from the LHS. If prove fails, backtracking is initiated causing the next rule which might match the goal pattern to be tried.
prove(IfList,
Tally) :-
prov(IfList, 100, Tally).
prov([], Tally, Tally).
prov([H|T],
CurTal, Tally) :-
findgoal(H, CF),
min(CurTal, CF, Tal),
Tal >= 20,
prov(T, Tal, Tally).
min(X, Y, X) :- X =< Y, !.
min(X, Y, Y) :- Y =< X.
The input argument to prove is the list of premises for the rule, and the output is the Tally, or combined CF from the premises. The prove predicate calls prov with an extra argument to keep track of Tally. At each recursion the Tally is reset to the minimum up to that point. Of course, prov recursively calls findgoal for each of the premises. Notice the check to make sure the Tally stays above 20. This is the threshold value for considering an attribute - value pair to be true.
After prove succeeds, adjust computes the combined CF based on the RHS CF and the Tally from the LHS.
adjust(CF1,
CF2, CF) :-
X is CF1 * CF2 / 100,
int_round(X, CF).
int_round(X,
I) :-
X >= 0,
I is integer(X + 0.5).
int_round(X,
I) :-
X < 0,
I is integer(X - 0.5).
Then update combines the new evidence for this attribute-value pair with any existing known evidence. The first argument is the attribute - value pair just deduced, and the second is its CF. The third argument is the returned value for the CF when it is combined with existing facts for the attribute-value pair.
update(Goal,
NewCF, CF) :-
fact(Goal, OldCF),
combine(NewCF, OldCF, CF),
retract( fact(Goal, OldCF) ),
asserta( fact(Goal, CF) ),
!.
update(Goal,
CF, CF) :-
asserta( fact(Goal, CF) ).
combine(CF1,
CF2, CF) :-
CF1 >= 0,
CF2 >= 0,
X is CF1 + CF2*(100 - CF1)/100,
int_round(X, CF).
combine(CF1,
CF2, CF) :-
CF1 < 0,
CF2 < 0,
X is - ( -CF1 -CF2 * (100 + CF1)/100),
int_round(X, CF).
combine(CF1,
CF2, CF) :-
(CF1 < 0; CF2 < 0),
(CF1 > 0; CF2 > 0),
abs_minimum(CF1, CF2, MCF),
X is 100 * (CF1 + CF2) / (100 - MCF),
int_round(X, CF).
The abs_minimum predicate finds the minimum in terms of absolute value. The code can be seen in the appendix.
Negation
One last point is to deal with negation. The premises might also be of the form not goal. In this case we call findgoal for the goal, and complement the CF to find the degree of certainty of its negation. For example if a fact has a CF of 70, then not fact has a certainty of -70.
findgoal(not
Goal, NCF) :-
findgoal(Goal, CF),
NCF is - CF, !.
This rule should become the first clause for findgoal.
Now that the inference engine is built, it can become part of a shell. The code to build this first version of the Clam shell is the same as that used to build the Native shell. It consists of a command loop with the commands load, consult, and exit. Figure 3.2 shows the architecture of Clam.
super :-
repeat,
write('consult, load, exit'), nl,
write(':'),
read_line(X),
doit(X),
X == exit.
doit(consult) :- top_goals, !.
doit(load) :- load_rules, !.
doit(exit).
Figure 3.2 Major predicates of the Clam shell
The consult command does a little more than just call findgoal. It calls top_goals which uses the top_goal facts to start the inference. The system might have more than one top_goal to allow sequencing of the consultation. For example a diagnostic system might have two goals, the first diagnoses the problem, and the second recommends a solution.
After top_goals satisfies a goal, it prints the values for the goal as seen in the early examples of Car.
top_goals
:-
top_goal(Attr),
top(Attr),
print_goal(Attr),
fail.
top_goals.
top(Attr)
:-
findgoal(av(Attr, Val), CF), !.
top(_) :- true.
print_goal(Attr)
:-
nl,
fact(av(Attr, X), CF),
CF >= 20,
outp(av(Attr, X), CF), nl,
fail.
print_goal(Attr) :-write('done with '), write(Attr), nl, nl.
outp(av(A,
V), CF) :-
output(A, V, PrintList),
write(A-'cf'-CF),
printlist(PrintList), !.
outp(av(A,
V), CF) :-
write(A-V-'cf'-CF).
printlist([]).
printlist([H|T])
:-
write(H),
printlist(T).
The load command for Clam does not simply read in Prolog terms as in Native, but instead uses DCG to read in a knowledge base in the format shown earlier in the chapter for the Car system. You might notice that the askable items have the additional syntax to allow menu choices which was not included in the implementation details above. It is coded similarly to the menu feature in Native.
The load_kb predicate in the shell gets a file name as in Native, and then calls load_rules with the file name.
load_rules(F)
:-
clear_db,
see(F),
lod_ruls,
write('rules loaded'), nl,
seen, !.
lod_ruls :-
repeat,
read_sentence(L),
process(L),
L == eof.
process(eof) :- !.
process(L)
:-
trans(R, L, []),
assertz(R), !.
process(L)
:-
write('translate error on:'), nl,
write(L), nl.
clear_db :-
abolish(top_goal, 1),
abolish(askable, 4),
abolish(rule, 3).
This section of code basically calls read_sentence to tokenize a sentence (up to a ".") into a list. The token list is then processed by the DCG predicate trans, and the resulting Prolog term, R, is asserted in the knowledge base. For a good description of DCG, see Clocksin & Mellish chapter 9, Using Grammar Rules. The clear_db predicate removes all earlier top_goal, askable, and rule predicates so that a new knowledge base can be loaded over an existing one.
The tokenizing predicate, read_sentence, varies from Prolog to Prolog based on the implementation. If the implementation has built-in predicates which can read tokens, then read_sentence is trivial. If not, it has to read the input character by character and build the tokens. An example of this type of sentence read predicate can be found in Clocksin & Mellish section 5.3, Reading English Sentences.
The top level DCG predicate, trans, looks for the three types of statements allowed in the knowledge base:
trans(top_goal(X))-->[goal, is, X].
trans(top_goal(X))-->[goal, X].
trans(askable(A,
M, P))-->
[ask, A], menux(M), prompt(A, P).
trans(rule(N, lhs(IF), rhs(THEN, CF)))--> id(N), if(IF), then(THEN, CF).
The following predicates recognize the menu and prompt fields in the ask statement.
menux(M)--> [menu, '('], menuxlist(M).
menuxlist([Item])--> [Item, ')'].
menuxlist([Item|T])--> [Item], menuxlist(T).
prompt(_, P)--> [prompt, P].
prompt(P, P)--> [].
Next are the predicates used to parse the basic rule structure. Note the flexibility that can be added into the system with DCG. Both and and ", " can be used as LHS separators. The attribute-value phrases can be expressed in many different ways to allow the most natural expression in the rules.
id(N)-->[rule, N].
if(IF)-->[if], iflist(IF).
iflist([IF])-->phrase(IF), [then].
iflist([Hif|Tif])-->phrase(Hif), [and], iflist(Tif).
iflist([Hif|Tif])-->phrase(Hif), [', '], iflist(Tif).
then(THEN, CF)-->phrase(THEN), [cf], [CF].
then(THEN, 100)-->phrase(THEN).
phrase(not av(Attr, yes))-->[not, Attr].
phrase(not av(Attr, yes))-->[not, a, Attr].
phrase(not av(Attr, yes))-->[not, an, Attr].
phrase(not av(Attr, Val))-->[not, Attr, is, Val].
phrase(not av(Attr, Val))-->[not, Attr, are, Val].
phrase(av(Attr, Val))-->[Attr, is, Val].
phrase(av(Attr, Val))-->[Attr, are, Val].
phrase(av(Attr, yes))-->[Attr].
Using DCG in this fashion, it is easy to implement as friendly a syntax for the knowledge base as desired. The same approach could also be used for the Native system, with DCG that translated English-like rules into Prolog syntax.
Now that we have a customized knowledge base and inference engine, it is possible to add other features to the system. The next chapter shows how to add explanations.
3.1 - Add attribute object value triples to the knowledge representation of Clam.
3.2 - There are other ways of dealing with uncertainty in the literature which could be used with Clam. A simple one would just use a few text modifiers such as weak, very weak, or strong and have rules for combining them. Implement this or some other scheme in Clam.
3.3 - Isolate the predicates which are used for calculating certainty factors so it is easy to add additional methods. Implement them so the calling predicates do not need to know the syntax of the certainty factor, since they might be text, numbers, or more complex data structures.
3.4 - Allow rules to have optional threshold values associated with them which override the default of 20. This would be an addition to the rule syntax as well as the code.
3.5 - Have the inference engine automatically generate a prompt to the user when there is no askable or rule which finds a value for an attribute.
3.6 - Add menus to the query user facility.
3.7 - Implement another diagnostic application using Clam. Note any difficulties and features which could be added to alleviate those difficulties.
Copyright ©1989,2000 Amzi! inc. All Rights Reserved.


Inspection reports are an essential part of the home buying process. We give them searchable structure and take them online. The home buyer can finally gain access to a clear and detailed inspection report, branded for you, the owner of the report.
The online report opens a communication channel between report owners (listing agents, home inspectors) and potential buyers, where buyers can point out concerns and agents can address these concerns in real-time.
Forget about counting disclosure packets as a proxy for interest. Get all the details about who opened the report, when, and what was important to them. Interact with them in real-time, and see who is really interested in the property.
Get competing improvement and renovation offers from top professionals in your area. Get better insurance rates. Letting professionals gain access to the report improves your brand and service you provide to your customers.
Whether you're a realtor who wants to give your customers an amazing service or a home inspector that wants to take the extra step - we're here to help! Send us the inspection report by email, upload or dropbox. PDF, Word, printed or hand written. 10 pages or 200 pages, printed or hand written - as long as it's readable, we'll take it!
Our team of experts read, analyze and digitize the report. We go over every tiny detail so that you won't have to, making sure everything is in place. We then feed all the details into our compute systems.
Our AI and machine learning systems generate a detailed, personalized report, branded with the owner of the report (realtor, home inspector), highlighting the items that are important to you and their quoted costs. Get a clear high-level summary of problems and concerns, or drill down to specific details. Easy access to the total reported costs, and comparison with similar properties in the area.
There are lots of benefits from having the inspection report available online. Buyers can comment and discuss concerns directly on the report, with realtors and home inspectors leveraging their expertise to help their customers. Professionals compete on beating the corrections and renovatons quotes in the report. Insurers give lower rates based on the condition of the property.
Whether you are the listing agent, or the buyer's agent, you can add value to your customer by having a clear, structured home inspection report.Moreover, you get full analytics of the potential buyers that accessed the report, and the ability communicate with them in real-time regarding concerns they might be having as they go over the report in the website.
Differentiate yourself for competitors by offering your inspection report online in a whole new way. In addition, once you use the service, you'll get a chance to propose competing quotes for your services in other inspection reports and engage with customers to show off your expertise.
Are you looking to buy a home and need some help with understanding the inspection report? Send it to us and we'll give you a summary of what matters most, all in one online report. As an added bonus, local professionals will compete on the renovation costs listed in the report, giving you the best deals with zero effort.
$49 / report
$199 / month
$399 / month
Let's talk
We're in private beta, working with a small selected set of customers.
Want to join?
Please leave your contact details and we'll be in touch as soon as we're ready.


%-- Document : game Created on : Mar 4, 2017, 6:56:31 AM Author : Cory Edwards --%> <%@page contentType="text/html" pageEncoding="UTF-8"%>
Player 1
Cells=
Player 2


style
settings
info
Picture attributes
Size
Any size
Large
Medium
Icon
Type
Any type
Face
Photo
Clip art
Line drawing
Animated
Color
Any color
Full color
Black and white
Transparent
Time and date
Any time
Past 24 hours
Past a week
Location
Radius:
0 km
Instagram/500px users
cristina_aguillera
justin_timberlake
tom_cruse
jessica_lopez
Settings
Info
Application info
search
arrow_upward
cristina_aguillera
justin_timberlake
tom_cruse
jessica_lopez
dwkafnkl


--- layout: post status: publish published: true title: Catching Up author: display_name: Tomas Restrepo login: tomasr email<EMAIL_ADDRESS>url: http://winterdom.com/ author_login: tomasr author_email<EMAIL_ADDRESS>author_url: http://winterdom.com/ wordpress_id: 540 wordpress_url: http://winterdom.com/2003/01/catchingup date: '2003-01-19 13:09:11 +0000' date_gmt: '2003-01-19 13:09:11 +0000' categories: - Personal tags: [] comments: [] ---
Ahh, it's good to be back home.... just got back from spending a nice week in beatiful Aruba :) I'm just starting to catch up from all that's happened in the newsgroups, weblogs, and, of course, work!


--- layout: post title: Loading the .Net SDK categories: [] tags: dotnet-sdk status: publish type: post published: true meta: {} ---
If you relied on us loading HP.HPTRIM.SDK.dll into the GAC you may have noticed that the 93 installer no longer does this, which has eliminated a number of messy deployment issues for us. For more information see the Microsoft guidelines re GAC installation.
A key benefit of GAC installation was the ability to write version agnostic SDK applications, the good news is that you can still do this. All you need to do is intercept the assembly loading pipeline and you can specify that HP.HPTRIM.SDK.dll gets loaded from the location specified in the registry.


[§136-3] Sale to minors; prohibited. It shall be unlawful to sell or furnish a laser pointing device to any minor. [L 1999, c 94, pt of §1]


|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |
| Deprecated Classes | |
|---|---|
| org.apache.shiro.crypto.hash.AbstractHash
in Shiro 1.1 in favor of using the concrete SimpleHash implementation directly. |
|
| org.apache.shiro.realm.ldap.DefaultLdapContextFactory
replaced by the JndiLdapContextFactory implementation. This implementation will be removed
prior to Shiro 2.0 |
|
| org.apache.shiro.web.servlet.IniShiroFilter
in 1.2 in favor of using the ShiroFilter |
|
| org.apache.shiro.authc.credential.Md2CredentialsMatcher
since 1.1 - use the HashedCredentialsMatcher directly and set its hashAlgorithmName property. |
|
| org.apache.shiro.authc.credential.Md5CredentialsMatcher
since 1.1 - use the HashedCredentialsMatcher directly and set its hashAlgorithmName property. |
|
| org.apache.shiro.authc.credential.Sha1CredentialsMatcher
since 1.1 - use the HashedCredentialsMatcher directly and set its hashAlgorithmName property. |
|
| org.apache.shiro.authc.credential.Sha256CredentialsMatcher
since 1.1 - use the HashedCredentialsMatcher directly and set its hashAlgorithmName property. |
|
| org.apache.shiro.authc.credential.Sha384CredentialsMatcher
since 1.1 - use the HashedCredentialsMatcher directly and set its hashAlgorithmName property. |
|
| org.apache.shiro.authc.credential.Sha512CredentialsMatcher
since 1.1 - use the HashedCredentialsMatcher directly and set its hashAlgorithmName property. |
| Deprecated Fields | |
|---|---|
| org.apache.shiro.web.mgt.DefaultWebSecurityManager.HTTP_SESSION_MODE
|
|
| org.apache.shiro.web.mgt.DefaultWebSecurityManager.NATIVE_SESSION_MODE
|
| Deprecated Methods | |
|---|---|
| org.apache.shiro.mgt.DefaultSecurityManager.bind(Subject)
in favor of save(subject) . |
|
| org.apache.shiro.realm.ldap.LdapContextFactory.getLdapContext(String, String)
the LdapContextFactory.getLdapContext(Object, Object) method should be used in all cases to ensure more than
String principals and credentials can be used. |
|
| org.apache.shiro.realm.ldap.JndiLdapContextFactory.getLdapContext(String, String)
the JndiLdapContextFactory.getLdapContext(Object, Object) method should be used in all cases to ensure more than
String principals and credentials can be used. Shiro no longer calls this method - it will be
removed before the 2.0 release. |
|
| org.apache.shiro.realm.ldap.DefaultLdapContextFactory.getLdapContext(String, String)
the DefaultLdapContextFactory.getLdapContext(Object, Object) method should be used in all cases to ensure more than
String principals and credentials can be used. Shiro no longer calls this method - it will be
removed before the 2.0 release. |
|
| org.apache.shiro.authc.credential.HashedCredentialsMatcher.getSalt(AuthenticationToken)
since Shiro 1.1. Hash salting is now expected to be based on if the AuthenticationInfo
returned from the Realm is a SaltedAuthenticationInfo instance and its
getCredentialsSalt() method returns a non-null value.
This method and the 1.0 behavior still exists for backwards compatibility if the Realm does not return
SaltedAuthenticationInfo instances, but it is highly recommended that Realm implementations
that support hashed credentials start returning SaltedAuthenticationInfo
instances as soon as possible.
This is because salts should always be obtained from the stored account information and
never be interpreted based on user/Subject-entered data. User-entered data is easier to compromise for
attackers, whereas account-unique (and secure randomly-generated) salts never disseminated to the end-user
are almost impossible to break. This method will be removed in Shiro 2.0. |
|
| org.apache.shiro.web.mgt.DefaultWebSecurityManager.getSessionMode()
|
|
| org.apache.shiro.authc.credential.HashedCredentialsMatcher.isHashSalted()
since Shiro 1.1. Hash salting is now expected to be based on if the AuthenticationInfo
returned from the Realm is a SaltedAuthenticationInfo instance and its
getCredentialsSalt() method returns a non-null value.
This method and the 1.0 behavior still exists for backwards compatibility if the Realm does not return
SaltedAuthenticationInfo instances, but it is highly recommended that Realm implementations
that support hashed credentials start returning SaltedAuthenticationInfo
instances as soon as possible.
This is because salts should always be obtained from the stored account information and
never be interpreted based on user/Subject-entered data. User-entered data is easier to compromise for
attackers, whereas account-unique (and secure randomly-generated) salts never disseminated to the end-user
are almost impossible to break. This method will be removed in Shiro 2.0. |
|
| org.apache.shiro.mgt.DefaultSubjectFactory.newSubjectInstance(PrincipalCollection, boolean, String, Session, SecurityManager)
since 1.2 - override DefaultSubjectFactory.createSubject(org.apache.shiro.subject.SubjectContext) directly if you
need to instantiate a custom Subject class. |
|
| org.apache.shiro.web.mgt.DefaultWebSubjectFactory.newSubjectInstance(PrincipalCollection, boolean, String, Session, ServletRequest, ServletResponse, SecurityManager)
since 1.2 - override DefaultWebSubjectFactory.createSubject(org.apache.shiro.subject.SubjectContext) directly if you
need to instantiate a custom Subject class. |
|
| org.apache.shiro.authc.credential.HashedCredentialsMatcher.setHashSalted(boolean)
since Shiro 1.1. Hash salting is now expected to be based on if the AuthenticationInfo
returned from the Realm is a SaltedAuthenticationInfo instance and its
getCredentialsSalt() method returns a non-null value.
This method and the 1.0 behavior still exists for backwards compatibility if the Realm does not return
SaltedAuthenticationInfo instances, but it is highly recommended that Realm implementations
that support hashed credentials start returning SaltedAuthenticationInfo
instances as soon as possible.
This is because salts should always be obtained from the stored account information and
never be interpreted based on user/Subject-entered data. User-entered data is easier to compromise for
attackers, whereas account-unique (and secure randomly-generated) salts never disseminated to the end-user
are almost impossible to break. This method will be removed in Shiro 2.0. |
|
| org.apache.shiro.realm.ldap.DefaultLdapContextFactory.setSearchBase(String)
this attribute existed, but was never used in Shiro 1.x. It will be removed prior to Shiro 2.0. |
|
| org.apache.shiro.web.mgt.DefaultWebSecurityManager.setSessionMode(String)
since 1.2 |
|
| org.apache.shiro.web.servlet.OncePerRequestFilter.shouldNotFilter(ServletRequest)
in favor of overriding OncePerRequestFilter.isEnabled(javax.servlet.ServletRequest, javax.servlet.ServletResponse)
for custom behavior. This method will be removed in Shiro 2.0. |
|
| org.apache.shiro.mgt.DefaultSecurityManager.unbind(Subject)
in Shiro 1.2 in favor of DefaultSecurityManager.delete(org.apache.shiro.subject.Subject) |
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |


|
MoveToCode
|
Bounds Control allows to transform objects (rotate and scale) and draws a cube around the object to visualize the possibility of user triggered transform manipulation. More...
Public Member Functions | |
| void | HighlightWires () |
| Allows to manually enable wire (edge) highlighting (edges) of the bounds control. More... | |
| void | UnhighlightWires () |
| void | CreateRig () |
| Destroys and re-creates the rig around the bounds control More... | |
| void | OnSourceDetected (SourceStateEventData eventData) |
| Raised when a source is detected. More... | |
| void | OnSourceLost (SourceStateEventData eventData) |
| Raised when a source is lost. More... | |
Properties | |
| GameObject | Target [get, set] |
| The object that the bounds control rig will be modifying. More... | |
| BoxCollider | BoundsOverride [get, set] |
| For complex objects, automatic bounds calculation may not behave as expected. More... | |
| BoundsCalculationMethod | CalculationMethod [get, set] |
| Defines the volume type and the priority for the bounds calculation More... | |
| BoundsControlActivationType | BoundsControlActivation [get, set] |
| Type of activation method for showing/hiding bounds control handles and controls More... | |
| FlattenModeType | FlattenAxis [get, set] |
| Flatten bounds in the specified axis or flatten the smallest one if 'auto' is selected More... | |
| Vector3 | BoxPadding [get, set] |
| Extra padding added to the actual Target bounds More... | |
| BoxDisplayConfiguration | BoxDisplayConfig [get, set] |
| Bounds control box display configuration section. More... | |
| LinksConfiguration | LinksConfig [get, set] |
| This section defines the links / lines that are drawn between the corners of the control. More... | |
| ScaleHandlesConfiguration | ScaleHandlesConfig [get, set] |
| Configuration of the scale handles. More... | |
| RotationHandlesConfiguration | RotationHandlesConfig [get, set] |
| Configuration of the rotation handles. More... | |
| TranslationHandlesConfiguration | TranslationHandlesConfig [get, set] |
| Configuration of the translation handles. More... | |
| ProximityEffectConfiguration | HandleProximityEffectConfig [get, set] |
| Configuration for Proximity Effect to scale handles or change materials on proximity. More... | |
| TextMesh | DebugText [get, set] |
| Component used to display debug messages. More... | |
| bool | HideElementsInInspector [get, set] |
| Determines whether to hide GameObjects (i.e handles, links etc) created and managed by this component in the editor More... | |
| bool | SmoothingActive [get, set] |
| Check to enable frame-rate independent smoothing. More... | |
| float | RotateLerpTime [get, set] |
| Enter amount representing amount of smoothing to apply to the rotation. More... | |
| float | ScaleLerpTime [get, set] |
| Enter amount representing amount of smoothing to apply to the scale. More... | |
| float | TranslateLerpTime [get, set] |
| Enter amount representing amount of smoothing to apply to the translation. More... | |
| bool | EnableConstraints [get, set] |
| nable or disable constraint support of this component. More... | |
| ConstraintManager | ConstraintsManager [get, set] |
| Constraint manager slot to enable constraints when manipulating the object. More... | |
| UnityEvent | RotateStarted [get, set] |
| Event that gets fired when interaction with a rotation handle starts. More... | |
| UnityEvent | RotateStopped [get, set] |
| Event that gets fired when interaction with a rotation handle stops. More... | |
| UnityEvent | ScaleStarted [get, set] |
| Event that gets fired when interaction with a scale handle starts. More... | |
| UnityEvent | ScaleStopped [get, set] |
| Event that gets fired when interaction with a scale handle stops. More... | |
| UnityEvent | TranslateStarted [get, set] |
| Event that gets fired when interaction with a translation handle starts. More... | |
| UnityEvent | TranslateStopped [get, set] |
| Event that gets fired when interaction with a translation handle stops. More... | |
| ElasticsManager | ElasticsManager [get, set] |
| Elastics Manager slot to enable elastics simulation when manipulating the object. More... | |
| bool | WireframeOnly [get] |
| Vector3[] | BoundsCorners [get] |
| BoxCollider | TargetBounds [get] |
| The collider reference tracking the bounds utilized by this component during runtime More... | |
| bool?? | Active [get, set] |
Bounds Control allows to transform objects (rotate and scale) and draws a cube around the object to visualize the possibility of user triggered transform manipulation.
Bounds Control provides scale and rotation handles that can be used for far and near interaction manipulation of the object. It further provides a proximity effect for scale and rotation handles that alters scaling and material.
| void Microsoft.MixedReality.Toolkit.UI.BoundsControl.BoundsControl.CreateRig | ( | ) |
Destroys and re-creates the rig around the bounds control
| void Microsoft.MixedReality.Toolkit.UI.BoundsControl.BoundsControl.HighlightWires | ( | ) |
Allows to manually enable wire (edge) highlighting (edges) of the bounds control.
This is useful if connected to the Manipulation events of a Microsoft.MixedReality.Toolkit.UI.ObjectManipulator when used in conjunction with this MonoBehavior.
| void Microsoft.MixedReality.Toolkit.UI.BoundsControl.BoundsControl.OnSourceDetected | ( | SourceStateEventData | eventData | ) |
Raised when a source is detected.
Implements Microsoft.MixedReality.Toolkit.Input.IMixedRealitySourceStateHandler.
| void Microsoft.MixedReality.Toolkit.UI.BoundsControl.BoundsControl.OnSourceLost | ( | SourceStateEventData | eventData | ) |
Raised when a source is lost.
Implements Microsoft.MixedReality.Toolkit.Input.IMixedRealitySourceStateHandler.
| void Microsoft.MixedReality.Toolkit.UI.BoundsControl.BoundsControl.UnhighlightWires | ( | ) |
|
getset |
|
getset |
Type of activation method for showing/hiding bounds control handles and controls
|
get |
|
getset |
For complex objects, automatic bounds calculation may not behave as expected.
Use an existing Box Collider (even on a child object) to manually determine bounds of bounds control.
|
getset |
Bounds control box display configuration section.
|
getset |
Extra padding added to the actual Target bounds
|
getset |
Defines the volume type and the priority for the bounds calculation
|
getset |
Constraint manager slot to enable constraints when manipulating the object.
|
getset |
Component used to display debug messages.
|
getset |
Elastics Manager slot to enable elastics simulation when manipulating the object.
|
getset |
nable or disable constraint support of this component.
When enabled, transform changes will be post processed by the linked constraint manager.
|
getset |
Flatten bounds in the specified axis or flatten the smallest one if 'auto' is selected
|
getset |
Configuration for Proximity Effect to scale handles or change materials on proximity.
|
getset |
Determines whether to hide GameObjects (i.e handles, links etc) created and managed by this component in the editor
|
getset |
This section defines the links / lines that are drawn between the corners of the control.
|
getset |
Enter amount representing amount of smoothing to apply to the rotation.
Smoothing of 0 means no smoothing. Max value means no change to value.
|
getset |
Event that gets fired when interaction with a rotation handle starts.
|
getset |
Event that gets fired when interaction with a rotation handle stops.
|
getset |
Configuration of the rotation handles.
|
getset |
Configuration of the scale handles.
|
getset |
Enter amount representing amount of smoothing to apply to the scale.
Smoothing of 0 means no smoothing. Max value means no change to value.
|
getset |
Event that gets fired when interaction with a scale handle starts.
|
getset |
Event that gets fired when interaction with a scale handle stops.
|
getset |
Check to enable frame-rate independent smoothing.
|
getset |
The object that the bounds control rig will be modifying.
|
get |
The collider reference tracking the bounds utilized by this component during runtime
|
getset |
Enter amount representing amount of smoothing to apply to the translation.
Smoothing of 0 means no smoothing. Max value means no change to value.
|
getset |
Event that gets fired when interaction with a translation handle starts.
|
getset |
Event that gets fired when interaction with a translation handle stops.
|
getset |
Configuration of the translation handles.
|
get |


This class computes and stores residuals for MPC QPs.
See mpc_data.h for the mathematical description.
Residuals have 3 components:
- z: Stationarity residual
- l: Equality residual
- v: Inequality/complimentarity residual
|
| | MpcResidual (int N, int nx, int nu, int nc) |
| | Allocates memory for the residual. More...
|
| |
| void | SetAlpha (double alpha) |
| | Sets the value of alpha used in residual computations, see (19) in https://arxiv.org/pdf/1901.04046.pdf. More...
|
| |
| void | Fill (double a) |
| | Fills the storage with all a. More...
|
| |
| void | Negate () |
| | Sets this <- -1 *this. More...
|
| |
| double | Norm () const |
| |
| double | Merit () const |
| |
| void | InnerResidual (const MpcVariable &x, const MpcVariable &xbar, double sigma) |
| | Computes R(x,xbar,sigma), the residual of a proximal subproblem and stores the result internally. More...
|
| |
| void | NaturalResidual (const MpcVariable &x) |
| | Computes π(x): the natural residual of the QP at the primal-dual point x and stores the result internally. More...
|
| |
| void | PenalizedNaturalResidual (const MpcVariable &x) |
| | Computes the natural residual function augmented with penalty terms, it is analogous to (18) in https://arxiv.org/pdf/1901.04046.pdf, and stores the result internally. More...
|
| |
| Eigen::VectorXd & | z () |
| | Accessor for stationarity residual. More...
|
| |
| const Eigen::VectorXd & | z () const |
| | Accessor for stationarity residual. More...
|
| |
| Eigen::VectorXd & | l () |
| | Accessor for the equality residual. More...
|
| |
| const Eigen::VectorXd & | l () const |
| | Accessor for the equality residual. More...
|
| |
| Eigen::VectorXd & | v () |
| | Accessor for complementarity residual. More...
|
| |
| const Eigen::VectorXd & | v () const |
| | Accessor for complementarity residual. More...
|
| |
| double | z_norm () const |
| | Norm of the stationarity residual. More...
|
| |
| double | l_norm () const |
| | Norm of the equality residual. More...
|
| |
| double | v_norm () const |
| | Norm of the complementarity residual. More...
|
| |
|
| | MpcResidual (const MpcResidual &)=delete |
| |
| MpcResidual & | operator= (const MpcResidual &)=delete |
| |
| | MpcResidual (MpcResidual &&)=delete |
| |
| MpcResidual & | operator= (MpcResidual &&)=delete |
| |
Computes R(x,xbar,sigma), the residual of a proximal subproblem and stores the result internally.
R(x,xbar,sigma) = 0 if and only if x = P(xbar,sigma) where P is the proximal operator.
See (11) and (20) in https://arxiv.org/pdf/1901.04046.pdf for a mathematical description.
- Parameters
-
| [in] | x | Inner loop variable |
| [in] | xbar | Outer loop variable |
| [in] | sigma | Regularization strength > 0 |
Throws a runtime_error if sigma isn't positive, or if x and xbar aren't the same size.


Class: Aws::NetworkManager::Types::GetNetworkRoutesRequest
| Relationships & Source Files | |
| Super Chains via Extension / Inclusion / Inheritance | |
|
Class Chain:
self,
Struct
|
|
|
Instance Chain:
self,
::Aws::Structure ,
Struct
|
|
| Inherits: |
Struct
|
| Defined in: | gems/aws-sdk-networkmanager/lib/aws-sdk-networkmanager/types.rb |
Overview
Constant Summary
Instance Attribute Summary
-
#destination_filters ⇒ Hash<String,Array<String>>
rw
Filter by route table destination.
-
#exact_cidr_matches ⇒ Array<String>
rw
An exact CIDR block.
-
#global_network_id ⇒ String
rw
The ID of the global network.
-
#longest_prefix_matches ⇒ Array<String>
rw
The most specific route that matches the traffic (longest prefix match).
-
#prefix_list_ids ⇒ Array<String>
rw
The IDs of the prefix lists.
-
#route_table_identifier ⇒ Types::RouteTableIdentifier
rw
The ID of the route table.
-
#states ⇒ Array<String>
rw
The route states.
-
#subnet_of_matches ⇒ Array<String>
rw
The routes with a subnet that match the specified CIDR filter.
-
#supernet_of_matches ⇒ Array<String>
rw
The routes with a CIDR that encompasses the CIDR filter.
-
#types ⇒ Array<String>
rw
The route types.
Instance Method Summary
::Aws::Structure
- Included
| #to_hash | Alias for Structure#to_h. |
Instance Attribute Details
#destination_filters ⇒ Hash
<String
,Array
<String
>> (rw)
Filter by route table destination. Possible Values: TRANSIT_GATEWAY_ATTACHMENT_ID, RESOURCE_ID, or RESOURCE_TYPE.
# File 'gems/aws-sdk-networkmanager/lib/aws-sdk-networkmanager/types.rb', line 3206
class GetNetworkRoutesRequest < Struct.new( :global_network_id, :route_table_identifier, :exact_cidr_matches, :longest_prefix_matches, :subnet_of_matches, :supernet_of_matches, :prefix_list_ids, :states, :types, :destination_filters) SENSITIVE = [] include Aws::Structure end
#exact_cidr_matches ⇒ Array
<String
> (rw)
An exact CIDR block.
# File 'gems/aws-sdk-networkmanager/lib/aws-sdk-networkmanager/types.rb', line 3206
class GetNetworkRoutesRequest < Struct.new( :global_network_id, :route_table_identifier, :exact_cidr_matches, :longest_prefix_matches, :subnet_of_matches, :supernet_of_matches, :prefix_list_ids, :states, :types, :destination_filters) SENSITIVE = [] include Aws::Structure end
#global_network_id ⇒ String
(rw)
The ID of the global network.
# File 'gems/aws-sdk-networkmanager/lib/aws-sdk-networkmanager/types.rb', line 3206
class GetNetworkRoutesRequest < Struct.new( :global_network_id, :route_table_identifier, :exact_cidr_matches, :longest_prefix_matches, :subnet_of_matches, :supernet_of_matches, :prefix_list_ids, :states, :types, :destination_filters) SENSITIVE = [] include Aws::Structure end
#longest_prefix_matches ⇒ Array
<String
> (rw)
The most specific route that matches the traffic (longest prefix match).
# File 'gems/aws-sdk-networkmanager/lib/aws-sdk-networkmanager/types.rb', line 3206
class GetNetworkRoutesRequest < Struct.new( :global_network_id, :route_table_identifier, :exact_cidr_matches, :longest_prefix_matches, :subnet_of_matches, :supernet_of_matches, :prefix_list_ids, :states, :types, :destination_filters) SENSITIVE = [] include Aws::Structure end
#prefix_list_ids ⇒ Array
<String
> (rw)
The IDs of the prefix lists.
# File 'gems/aws-sdk-networkmanager/lib/aws-sdk-networkmanager/types.rb', line 3206
class GetNetworkRoutesRequest < Struct.new( :global_network_id, :route_table_identifier, :exact_cidr_matches, :longest_prefix_matches, :subnet_of_matches, :supernet_of_matches, :prefix_list_ids, :states, :types, :destination_filters) SENSITIVE = [] include Aws::Structure end
#route_table_identifier ⇒ Types::RouteTableIdentifier (rw)
The ID of the route table.
# File 'gems/aws-sdk-networkmanager/lib/aws-sdk-networkmanager/types.rb', line 3206
class GetNetworkRoutesRequest < Struct.new( :global_network_id, :route_table_identifier, :exact_cidr_matches, :longest_prefix_matches, :subnet_of_matches, :supernet_of_matches, :prefix_list_ids, :states, :types, :destination_filters) SENSITIVE = [] include Aws::Structure end
#states ⇒ Array
<String
> (rw)
The route states.
# File 'gems/aws-sdk-networkmanager/lib/aws-sdk-networkmanager/types.rb', line 3206
class GetNetworkRoutesRequest < Struct.new( :global_network_id, :route_table_identifier, :exact_cidr_matches, :longest_prefix_matches, :subnet_of_matches, :supernet_of_matches, :prefix_list_ids, :states, :types, :destination_filters) SENSITIVE = [] include Aws::Structure end
#subnet_of_matches ⇒ Array
<String
> (rw)
The routes with a subnet that match the specified CIDR filter.
# File 'gems/aws-sdk-networkmanager/lib/aws-sdk-networkmanager/types.rb', line 3206
class GetNetworkRoutesRequest < Struct.new( :global_network_id, :route_table_identifier, :exact_cidr_matches, :longest_prefix_matches, :subnet_of_matches, :supernet_of_matches, :prefix_list_ids, :states, :types, :destination_filters) SENSITIVE = [] include Aws::Structure end
#supernet_of_matches ⇒ Array
<String
> (rw)
The routes with a CIDR that encompasses the CIDR filter. Example: If you specify <IP_ADDRESS>/30, then the result returns <IP_ADDRESS>/29.
# File 'gems/aws-sdk-networkmanager/lib/aws-sdk-networkmanager/types.rb', line 3206
class GetNetworkRoutesRequest < Struct.new( :global_network_id, :route_table_identifier, :exact_cidr_matches, :longest_prefix_matches, :subnet_of_matches, :supernet_of_matches, :prefix_list_ids, :states, :types, :destination_filters) SENSITIVE = [] include Aws::Structure end
#types ⇒ Array
<String
> (rw)
The route types.
# File 'gems/aws-sdk-networkmanager/lib/aws-sdk-networkmanager/types.rb', line 3206
class GetNetworkRoutesRequest < Struct.new( :global_network_id, :route_table_identifier, :exact_cidr_matches, :longest_prefix_matches, :subnet_of_matches, :supernet_of_matches, :prefix_list_ids, :states, :types, :destination_filters) SENSITIVE = [] include Aws::Structure end


| Setting | Description |
|---|---|
| Icinga Data URL | The absolute URL to your Icinga setup or API. Both HTTPS and HTTP URL's work. Trailing slash is optional. Example: https://myicingaserver.com/icinga/ or https://myicingaserver.com:5665/ |
| Icingaweb 2 URL | The absolute URL to your Icingaweb2 instance while you use the Icinga 2 API and therefore this is optional. Enables correct linking of hosts and services. Trailing slash is optional. Example: https://myicingaserver.com/icingaweb2/ |
| Instance Title | A short but recognizable title for your Icinga instance used by this extension. Example: My Icinga Instance |
| Username | If your Icinga instance requires an authentication, you can place the username here. If you use the Icinga 2 API type, put your API user here. Example: icingaadmin |
| Password | If your Icinga instance requires an authentication, you can place the password to the above username here. If you use the Icinga 2 API type, put your API password here. Example: icingaadmin |
| Hide and ignore hosts | Regular Expression to hide/ignore specific hosts from showing up in the monitoring. You won't receive notifications or alerts of matching hosts. They also not showing up in the overview lists. Example: web[0-9]+ |
| Hide and ignore services | Regular Expression to hide/ignore specific services from showing up in the monitoring. You won't receive notifications or alerts of matching services. They also not showing up in the overview lists. Example: (imap|ssh) |
| Ignore acknowleged host & service problems | If you acknowledge a host or service problem in Icinga, you won't get notified or alerted here if enabled. |
| Ignore hosts & services with downtimes | If a scheduled downtime is active for a host or service in Icinga, you won't get notified or alerted here if enabled. |
| Ignore hosts & services with problems in SOFT state | Only respects problems in HARD state if enabled. |
| No notifications for warnings | If enabled, you won't get any notifications for service warnings. |
# Run the automatic setup $ icinga2 api setup # Restart the icinga2 service $ service icinga2 restart
| Badge Layout | Description |
|---|---|
| "..." on mild blue background | Icinga Multi Status is refreshing it's data by querying your Icinga instances. |
| Digit on purple background | Amount of Icinga instances having problems (Can't connect to Icinga instance) |
| Digit on pink background | Amount of services having UNKNOWN status |
| Digit on orange background | Amount of services having WARNING status |
| Digit on red background | Amount of hosts having DOWN/UNREACHABLE status and services having CRITICAL status |
| Digit on green background | Amount of hosts having UP status (also means everything ok) |


This document contains typical NiftyGUI usecase scenarios, such as adding effects, game states, and creating typical game screens.
Requirements: These tips assume that you have read and understood the Creating JME3 User Interfaces with Nifty GUI tutorial, and have already laid out a basic GUI that interacts with your JME3 application. Here you learn how you integrate the GUI better, and add effects and advanced controls.
In a JME game, you typically have three game states:
(Aside: Additionally, the Stopped state often contains a LoadScreen, LogonScreen, OptionsScreen, CharacterCreationScreen, HighScoreScreen, CreditsScreen, etc. Some games let you access the OptionsScreen in the Paused state as well. The Running state can also contain an InventoryScreen, ItemShopScreen, StatsScreen, SkillScreen, etc.)
In JME, game states are implemented as custom AppState objects. Write each AppState so it brings its own input mappings, rootNode content, update loop behaviour, etc with it.
When the player switches between game states, you detach one set of AppStates, and attach another. For example, when the player pauses the running game, you use a boolean switch to pause the game loop and deactivate the game inputs (shooting, navigation). The screen is overlayed with a PausedScreen, which contains a visible mouse pointer and a Continue button. When the player clicks Continue, the mouse pointer is deactivated, the in-game input and navigational mappings are activated, and the game loop continues.
Since you are writing a jME3 application, you can additionally make any ScreenController class extend the AbstractAppState class. This gives the ScreenController access to the application object and to the update loop!
public class StartScreenState extends AbstractAppState { private ViewPort viewPort; private Node rootNode; private Node guiNode; private AssetManager assetManager; private Node localRootNode = new Node("Start Screen RootNode"); private Node localGuiNode = new Node("Start Screen GuiNode"); private final ColorRGBA backgroundColor = ColorRGBA.Gray; public StartScreenState(SimpleApplication app){ this.rootNode = app.getRootNode(); this.viewPort = app.getViewPort(); this.guiNode = app.getGuiNode(); this.assetManager = app.getAssetManager(); } @Override public void initialize(AppStateManager stateManager, Application app) { super.initialize(stateManager, app); /** init the screen */ } @Override public void update(float tpf) { /** any main loop action happens here */ } @Override public void stateAttached(AppStateManager stateManager) { rootNode.attachChild(localRootNode); guiNode.attachChild(localGuiNode); viewPort.setBackgroundColor(backgroundColor); } @Override public void stateDetached(AppStateManager stateManager) { rootNode.detachChild(localRootNode); guiNode.detachChild(localGuiNode); } }
| Variable | Description |
|---|---|
| ${CALL.myMethod()} | Calls a method in the current ScreenController and gets the method's return String. The method can also be void and have a side effect, e.g. play a sound etc. |
| ${ENV.HOME} | Returns the path to user's home directory. |
| ${ENV.key} | Looks up key in the environment variables. Use it like Java's System.getEnv("key"). |
| ${PROP.key} | looks up key in the Nifty properties. Use Nifty.setGlobalproperties(properties) and Nifty.getGlobalproperties("key"). Or SystemGetProperties(key); |
See also:
Technically you are free to create one ScreenController class for each screen, or reuse the same ScreenController for all or some of them. In the end it may be best to create individual ScreenControllers for functionality that is mutually exclusive.
For example, create a MyHudScreen.java
for the hud
screen, and a MyStartScreen.java
for the start
screen.
MyHudScreen.java
. Then make this class control all screens that can be up during the game (the HUD screen, a MiniMap screen, an Inventory screen, an Abilities or Skills screen, etc). All these screens possibly share data (game data, player data), so it makes sense to control them all with methods of the same MyHudScreen.java
class.MyStartScreen.java
. Then make this class control all screens that can be up outside the game (the Start screen, a Settings/Options screen, a HighScore screen, etc). All these classes need to read and write saved game data, so it makes sense to control them all with methods of the same MyStartScreen.java
class.Get the full Loading Screen tutorial here.
Get the full Nifty GUI PopUp Menu tutorial here.
You can register effects to screen elements.
Here is an example that moves a panel when the startScreen opens. You place an < effect > tag inside the element that you want to be affected.
<panel height="25%" width="35%" ...> <effect> <onStartScreen name="move" mode="in" direction="top" length="300" startDelay="0" inherit="true"/> </effect> </panel>
Learn more from the NiftyGUI page:
Playing sounds using Nifty is also possible with a playSound
effect as trigger. Remember to first register the sound that you want to play:
<registerSound id="myclick" filename="Interface/sounds/ButtonClick.ogg" /> ... <label> <effect> <onClick name="playSound" sound="myclick"/> </effect> </label>
After a mouse click, you may want to record the 2D clickLoc and send this info to your Java application. Typical ScreenController methods however only have a String argument. You'd have to convert the String to ints.
To pass the clickLoc as two ints, you can use the special (int x, int y)
syntax in the ScreenController:
public void clicked(int x, int y) { // here you can use the x and y of the clickLoc }
In the Nifty GUI screen code (e.g. XML file) you must call the (int x, int y)
method without any parameters!
<interact onClick="clicked()"/>
You can name the method (here clicked
) what ever you like, as long as you keep the argument syntax.
The basic Nifty GUI example showed how to use the nifty.fromXML()
method to load one XML file containing all Nifty GUI screens.
The following code sample shows how you can load several XML files into one nifty object. Loading several files with nifty.addXml()
allows you to split up each screen into one XML file, instead of all into one hard-to-read XML file.
NiftyJmeDisplay niftyDisplay = new NiftyJmeDisplay(assetManager, inputManager, audioRenderer, viewPort); Nifty nifty = niftyDisplay.getNifty(); nifty.addXml("Interface/Screens/OptionsScreen.xml"); nifty.addXml("Interface/Screens/StartScreen.xml"); nifty.gotoScreen("startScreen"); StartScreenControl screenControl = (StartScreenControl) nifty.getScreen("startScreen").getScreenController(); OptionsScreenControl optionsControl = (OptionsScreenControl) nifty.getScreen("optionsScreen").getScreenController(); stateManager.attach(screenControl); stateManager.attach(optionsControl); guiViewPort.addProcessor(niftyDisplay);
In addition to the nifty.addXml()
methods to attach many nifty XML files, there exists a nifty.registerScreenController()
method to explicitly attach more screen controllers.
The following code sample shows how you can explicitly attach several screen controllers before adding the XML file to nifty, which would otherwise cause nifty to implicitly instantiate the screen controller class.
NiftyJmeDisplay niftyDisplay = new NiftyJmeDisplay(assetManager, inputManager, audioRenderer, viewPort); Nifty nifty = niftyDisplay.getNifty(); nifty.registerScreenController(new OptionsScreenController(randomConstructorArgument)); nifty.addXml("Interface/Screens/OptionsScreen.xml");
By default, your Nifty XML screens use the built.in styles:
<useStyles filename="nifty-default-styles.xml" />
But you can switch to a set of custom styles in your game project's asset directory like this:
<useStyles filename="Interface/Styles/myCustomStyles.xml" />
Inside myCustomStyles.xml you define styles like this:
<?xml version="1.0" encoding="UTF-8"?> <nifty-styles> <useStyles filename="Interface/Styles/Font/myCustomFontStyle.xml" /> <useStyles filename="Interface/Styles/Button/myCustomButtonStyle.xml" /> <useStyles filename="Interface/Styles/Label/myCustomLabelStyle.xml" /> ... </nifty-styles>
Learn more about how to create styles by looking at the for “nifty-style-black”. Copy it as a template and change it to create your own style.
Learn more from the NiftyGUI page:


MKMetrics Class Reference
| Inherits from | MKObject : NSObject |
| Declared in | MKMetrics.h |
Overview
Overview
MKMetrics provides a methods for the persion layout of subviews during changes in orientation or screen size.
Usage
Before calling any of the layout methods make sure a superview is assigned you can do this by using the metricsForView: method for creating your instance, or assign a superview to the view property.
All calls the layoutSubview:forMetrics: need to enclosed in beginLayout and endLayout methods.
MKMetrics works in conjunction with the UIView+MKMetrics catagory use the methods in this catagory to set up how subview should be layed out.
MKMetrics Supports ARC
Tasks
Create Instance
-
+ metricsForView:
Creates an instance of MKMetrics and assigns the passed UIView to the view property.
Layout
-
- beginLayout
Prepares to layout subviews -
- layoutSubview:forMetrics:
Will layout the given subview using the location/size set with UIView+MKMetrics catagory methods. -
- endLayout
Cleans up after a subview layout.
Layout Options
-
- horizontallyCenterView:
Will horizontally center the give view with in the view that was given when the instance was created using themetricsForViewMethod
.
Referencing
-
view
The suberview that contains the subviews to layout.
Class Methods
Instance Methods
horizontallyCenterView:
Will horizontally center the give view with in the view that was given when the instance was created using the metricsForViewMethod
.
- (void)horizontallyCenterView:(UIView *)subview
Parameters
- subview
- The view to center
Declared In
MKMetrics.h
layoutSubview:forMetrics:
Will layout the given subview using the location/size set with UIView+MKMetrics catagory methods.
- (void)layoutSubview:(UIView *)subview forMetrics:(MKViewMetrics)metrics
Parameters
- subview
- The subview to layout
- metrics
- The metrics to use to layout the subview. You can use the following fuctions to find the witch MKViewMetrics to pass:
- MKViewMetrics MKMetricsCurrentOrientationMetrics(void)
- MKViewMetrics MKMetricsOrientationMetrics(UIInterfaceOrientation orientation)
Declared In
MKMetrics.h


{# # Licensed 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. -#} {% extends "base.html" %} {% block title %}Search results{% endblock %} {% macro project_snippet(item) -%} {% set version = item.version[0] %}
{{ item.summary }}


Using this 'Add-On' means connecting it to Github via OAuth.
This happens the first time you click on 'Start Publishing', when you grant permissions for Gabriel to publish to your repositories on your behalf.
Currently, this means you can only be 'signed' into a single account at any one time. If you would like to publish using a different account, you will need to click the button below to begin the authorisation process again.
: You have already authorised this add-on to access your GitHub Account.
You can view the details of this application on your GitHub account.
If you would like to change the account you are using to access GitHub, please sign out of GitHub and click on the 'Authorise' button below.


Classes
- BaseComponent
Constructs an object of type
BaseComponent
and does all operations that are common for custom elements that extendBaseComponent
.- ToggleButton
Class for 'toggle-button' custom element.
- ValueSelectButton
Class for 'value-select-button' custom element.


This project allows you to collect logs related to the access of your files.
Check out this project's activity page to see how notebooks, projects, and members are using & sharing this data. (Once connected, you can also find your data on this page!)
This connection provides two sets of csv formatted files. The first set contains logs to access events through the Open Humans interface. The second set contains access events of the files themselves as they rest in S3 on Amazon's servers. These files contain, as their first line, a header with column definitions, followed by each event on its own line, separated by commas.
This site is managed by Open Humans and follows the same terms of use. Data stored in Open Humans is private by default: it's your personal archive and always available to you, and you choose when to share with others.


AWS::WAF::WebACL
The AWS::WAF::WebACL
resource creates an AWS WAF web access control group
(ACL) containing the rules that identify the Amazon CloudFront (CloudFront) web requests
that you want to
allow, block, or count. For more information, see CreateWebACL in the
AWS WAF API Reference.
Syntax
To declare this entity in your AWS CloudFormation template, use the following syntax:
JSON
{ "Type" : "AWS::WAF::WebACL", "Properties" : { "DefaultAction" :
Action
, "MetricName" :String
, "Name" :String
, "Rules" : [Rule, ...
] } }
YAML
Type: "AWS::WAF::WebACL" Properties: DefaultAction:
Action
MetricName:String
Name:String
Rules: -Rule
Properties
DefaultAction
-
The action that you want AWS WAF to take when a request doesn't match the criteria in any of the rules that are associated with the web ACL.
Required: Yes
Type: AWS WAF WebACL Action
Update requires: No interruption
MetricName
-
A friendly name or description for the Amazon CloudWatch metric of this web ACL. For valid values, see the
MetricName
parameter of the CreateWebACL action in the AWS WAF API Reference.Required: Yes
Type: String
Update requires: Replacement
Name
-
A friendly name or description of the web ACL.
Required: Yes
Type: String
Update requires: Replacement
Rules
-
The rules to associate with the web ACL and the settings for each rule.
Required: No
Type: List of AWS WAF WebACL ActivatedRule
Update requires: No interruption
Return Values
Ref
When the logical ID of this resource is provided to the Ref
intrinsic function, Ref
returns the resource name, such as
1234a1a-a1b1-12a1-abcd-a123b123456
.
For more information about using the Ref
function, see Ref.
Examples
Create a Web ACL
The following example defines a web ACL that allows, by default, any web request. However, if the request matches any rule, AWS WAF blocks the request. AWS WAF evaluates each rule in priority order, starting with the lowest value.
JSON
"MyWebACL": { "Type": "AWS::WAF::WebACL", "Properties": { "Name": "WebACL to with three rules", "DefaultAction": { "Type": "ALLOW" }, "MetricName" : "MyWebACL", "Rules": [ { "Action" : { "Type" : "BLOCK" }, "Priority" : 1, "RuleId" : { "Ref" : "MyRule" } }, { "Action" : { "Type" : "BLOCK" }, "Priority" : 2, "RuleId" : { "Ref" : "BadReferersRule" } }, { "Action" : { "Type" : "BLOCK" }, "Priority" : 3, "RuleId" : { "Ref" : "SqlInjRule" } } ] } }
YAML
MyWebACL: Type: "AWS::WAF::WebACL" Properties: Name: "WebACL to with three rules" DefaultAction: Type: "ALLOW" MetricName: "MyWebACL" Rules: - Action: Type: "BLOCK" Priority: 1 RuleId: Ref: "MyRule" - Action: Type: "BLOCK" Priority: 2 RuleId: Ref: "BadReferersRule" - Action: Type: "BLOCK" Priority: 3 RuleId: Ref: "SqlInjRule"
Associate a Web ACL with a CloudFront Distribution
The follow example associates the MyWebACL
web ACL with a CloudFront distribution.
The web ACL restricts which requests can access content served by CloudFront.
JSON
"myDistribution": { "Type": "AWS::CloudFront::Distribution", "Properties": { "DistributionConfig": { "WebACLId": { "Ref" : "MyWebACL" }, "Origins": [ { "DomainName": "test.example.com", "Id": "myCustomOrigin", "CustomOriginConfig": { "HTTPPort": "80", "HTTPSPort": "443", "OriginProtocolPolicy": "http-only" } } ], "Enabled": "true", "Comment": "TestDistribution", "DefaultRootObject": "index.html", "DefaultCacheBehavior": { "TargetOriginId": "myCustomOrigin", "SmoothStreaming" : "false", "ForwardedValues": { "QueryString": "false", "Cookies" : { "Forward" : "all" } }, "ViewerProtocolPolicy": "allow-all" }, "CustomErrorResponses" : [ { "ErrorCode" : "404", "ResponsePagePath" : "/error-pages/404.html", "ResponseCode" : "200", "ErrorCachingMinTTL" : "30" } ], "PriceClass" : "PriceClass_200", "Restrictions" : { "GeoRestriction" : { "RestrictionType" : "whitelist", "Locations" : [ "AQ", "CV" ] } }, "ViewerCertificate" : { "CloudFrontDefaultCertificate" : "true" } } } }
YAML
myDistribution: Type: "AWS::CloudFront::Distribution" Properties: DistributionConfig: WebACLId: Ref: "MyWebACL" Origins: - DomainName: "test.example.com" Id: "myCustomOrigin" CustomOriginConfig: HTTPPort: "80" HTTPSPort: "443" OriginProtocolPolicy: "http-only" Enabled: "true" Comment: "TestDistribution" DefaultRootObject: "index.html" DefaultCacheBehavior: TargetOriginId: "myCustomOrigin" SmoothStreaming: "false" ForwardedValues: QueryString: "false" Cookies: Forward: "all" ViewerProtocolPolicy: "allow-all" CustomErrorResponses: - ErrorCode: "404" ResponsePagePath: "/error-pages/404.html" ResponseCode: "200" ErrorCachingMinTTL: "30" PriceClass: "PriceClass_200" Restrictions: GeoRestriction: RestrictionType: "whitelist" Locations: - "AQ" - "CV" ViewerCertificate: CloudFrontDefaultCertificate: "true"


ASP.NET Boilerplate uses Castle Windsor's logging facility. It can work with different logging libraries: Log4Net, NLog, Serilog... etc. Castle provides a common interface for all logger libraries. So, you're independent from specific logging library and can easily change it later if you need.
Log4Net is one of the most popular logging libraries for .NET. ASP.NET Boilerplate templates come with Log4Net properly configured and working. But, there is just a single-line of dependency to log4net (as seen in configuration section), so you can change it to your favourite library.
No matter which logging library you choice, the code to write log is same (thanks to Castle's common ILogger interface).
First, we should handle a Logger object to write logs. Since ASP.NET Boilerplate strongly uses dependency injection, we can easily inject a Logger object using property injection pattern. See a sample class that writes a log line:
using Castle.Core.Logging; //1: Import Logging namespace
public class TaskAppService : ITaskAppService
{
//2: Getting a logger using property injection
public ILogger Logger { get; set; }
public TaskAppService()
{
//3: Do not write logs if no Logger supplied.
Logger = NullLogger.Instance;
}
public void CreateTask(CreateTaskInput input)
{
//4: Write logs
Logger.Info("Creating a new task with description: " + input.Description);
//TODO: save task to database...
}
}
First, we imported namespace of Castle's ILogger interface.
Second, we defined a public ILogger object named Logger. This is the object we will write logs. Dependency injection system will set (inject) this property after creating TaskAppService object. This is known as property injection pattern.
Third, we set Logger to NullLogger.Instance. System will work fine without this line. But this is best practice on property injection pattern. If no one sets the Logger, it will be null and we get an "object reference..." exception when we want to use it. This guaranties that it's not null. So, if no one sets the Logger, it will be NullLogger. This is known as null object pattern. NullLogger actually does nothing, does not write any logs. Thus, our class can work with and without an actual logger.
Fourth and the last, we're writing a log text with info level. There are different levels (see configuration section).
If we call the CreateTask method and check the log file, we see a log line as like as shown below:
INFO 2014-07-13 13:40:23,360 [8 ] SimpleTaskSystem.Tasks.TaskAppService - Creating a new task with description: Remember to drink milk before sleeping!
ASP.NET Boilerplate provides base classes for MVC controllers, Web API controllers and Application service classes. They declare a Logger property. So, you can directly use this Logger to write logs, no injection needed. Example:
public class HomeController : SimpleTaskSystemControllerBase
{
public ActionResult Index()
{
Logger.Debug("A sample log message...");
return View();
}
}
Note that SimpleTaskSystemControllerBase is our application specific base controller that inherits AbpController. Thus, it can directly use Logger. Logger also exists in AbpApiController base class for Web API Controllers and ApplicationService class for application services.. You can also write your own common base class for other classes. Then, you will not have to inject logger every time.
All configuration is done for Log4Net when you create your application from ASP.NET Boilerplate templates.
Default configuration's log format is as show below (for each line):
It's defined in the log4net.config file of the application as shown below:
<?xml version="1.0" encoding="utf-8" ?>
<log4net>
<appender name="RollingFileAppender" type="log4net.Appender.RollingFileAppender" >
<file value="Logs/Logs.txt" />
<appendToFile value="true" />
<rollingStyle value="Size" />
<maxSizeRollBackups value="10" />
<maximumFileSize value="10000KB" />
<staticLogFileName value="true" />
<layout type="log4net.Layout.PatternLayout">
<conversionPattern value="%-5level %date [%-5.5thread] %-40.40logger - %message%newline" />
</layout>
</appender>
<root>
<appender-ref ref="RollingFileAppender" />
<level value="DEBUG" />
</root>
<logger name="NHibernate">
<level value="WARN" />
</logger>
</log4net>
Log4Net is highly configurable and strong logging library. You can write logs in different formats and to different targets (text file, database...). You can set minimum log levels (as set for NHibernate in this configuration). You can write diffent loggers to different log files. It can automatically backup and create new log file when it reaches to a specific size (Rolling file adapter with 10000 KB per file in this configuration) and so on... Read it's own confuguration documentation for more.
Finally, in the Global.asax file, we declare that we use Log4Net with log4net.config file:
public class MvcApplication : AbpWebApplication
{
protected override void Application_Start(object sender, EventArgs e)
{
IocManager.Instance.IocContainer.AddFacility<LoggingFacility>(f => f.UseLog4Net().WithConfig("log4net.config"));
base.Application_Start(sender, e);
}
}
This is the only code line we directly depend on log4net. Also, only the web project depends on log4net library's nuget package. So, you can easily change to another library without changing your logging code.
ASP.NET Boilerplate defines a javascript logging API for client side. It logs to browser's console as default. Sample javascript code to write logs:
abp.log.warn('a sample log message...');
For more information, see logging API documentation.


Swap
Resume
Withdraw
Sellers
History
Swap failed?
Your funds are safe
Refund to Your Original Bitcoin Wallet
BTC Refund Address


curveto(h1x, h1y, h2x, h2y, x, y, close=False)
Draws a curve between the current point in the path and a new "destination" point. The pair of positional args, x
and y
, set the location of the destination point. The first two pairs of arguments set the location of the two ‘control points’ of the curve. These control points (or handles in Illustrator nomenclature) define the edge and slant of the curve.
If the close
argument is set to True
, a lineto() command will be synthesized connecting the end of the curve to the origin point of the active subpath.
The curveto() command must be called inside a bezier() context (or between beginpath() and endpath()).
nofill() stroke(0.2) with bezier(10,50) as path: curveto(10,0, 110,100, 110,50)or
nofill() stroke(0.2) autoclosepath(False) beginpath(10, 50) curveto(10,0, 110,100, 110,50) path = endpath()