This is our exclusive beginner camp program. It is for the first time camper who may be a little reluctant to leave home. This program offers additional counselor support and takes no overnight camping trips.
This is our traditional program for returning campers or new campers who are comfortable leaving home. This program incorporates our old fashioned outdoor activities plus canoe, backpack and bike camping trips.
This program is for campers who wish to accomplish more during the summer and have the time available. Many returning campers select this program. Limited to 20 children.
Our teen leadership program is designed for young adults who are too old to be campers and want to be leaders to our campers. We teach CIT's how to motivate, care for and deal with young people. They get hands on experience and responsibility in daily camp life.
Thus adventure is open to older campers who are physically active and have canoeing experience. Our trip is a wonderful opportunity to see the pristine boundary waters area of Canada and northern Minnesota.
The state of Wisconsin has given us a directive to provide a quality summer camp experience which increases a child's environmental awareness at a cost below that of comparable private residential camps. On average, savings may be as much as $500 per week compared to similar programs offered by private camps.
The state of Wisconsin has given us a directive to provide a quality summer camp experience which increases a child's environmental awareness at a cost below that of comparable private residential camps. On average, savings may be as much as $500 per week compared to similar programs offered by private camps.
Children enjoy going to camp with siblings and friends because they feel more at ease and have more fun. For every friend or relative (three or more) you send to Swift Nature Camp, we will discount each child's tuition $50. When Completing the application form, just email us a note saying who the other two campers will be.
America summer camps are a wonderful way for children to practice English Language Immersion. Children practice using English in a fun sportive environment while making new friends.
The state of Wisconsin has given us a directive to provide a quality summer camp experience which increases a child's environmental awareness at a cost below that of comparable private residential camps. On average, savings may be as much as $500 per week compared to similar programs offered by private camps.
Partial scholarships are available for those campers requesting assistance. A limited number of reduced registration fee scholarships are awarded on a space available basis. Applications must be returned with a minimum deposit of $300. Enrollment is not guaranteed. On June 1st, prospective campers will be notified whether their scholarship applications have been accepted or denied. Upon camper acceptance, payment in full will be due within 2 weeks.
It is simple. Complete the online registration and make a minimum deposit of $100 with credit card or echeck. Our online registration system will allow you to create an account and keep track of all required paperwork as well as any payment you have made.
All payments are fully refundable for any cancellation prior to April 1st. SHould you need to cancel prior to camp starting but after April 1, a $250 service charge applies to all refunds. During camp, there can be no reduction in tuition if a camper arrives late, leaves early or temporarily departs for a given time.


directions_boat
About
All
Start
Github
About
All
Start
Github
Photography
Unsplash
Google Photos Portfolio
Writing
Medium


Hello there! My name is Leanne Chin and I am currently in my Sophomore Year in Drexel University studying Interactive Digital Media. All my life I have lived in beautiful, lively NYC, yet I have switched to a completely new city to live in.
Although changing from NYC to Philly has been a huge jump, growing up in the "city that never sleeps" has exposed me to many different cultures and industries that I try to apply to my everday life.
Growing up, I was trained for dance in the heart of the Theater District. Living in that industry allowed me to create a strong love for musical theater. It has always been a strong, yet temporary escape from the grueling realities that we live in. While I was out of dance and out of my daydreaming fantasies, I was always in different types of sports ranging from basketball to golf, or from ice skating to gymnastics. The adrenaline rush that rushed through my body as I sprinted towards the net to stop a volleyball from touching the floor was unlike anything that you can feel. The constant energy that I got from dance and sports factored very much into the happiness that I exerted each day, bringing smiles to my face and to others.
However, the number one thing that hugs my heart the most, growing the widest grin, is my love of Disney. When you first think of Disney, what is the first thing that comes to mind? Maybe childish, or is it magical? For me, it’s a magical fantasy that is purely amazing. Disney has created these worlds that always pulls you into their stories, and out of our horrifying realities in the real world. Not only that, but brings back our fondest childhood memories. Disney simply knows how to make my inner child shine through. It not only helped me through the good times and the bad times, but it has helped me connect with others of all ages. Whenever possible, I try to sprinkle a bit of my own Disney magic.
When I did jump back into reality, I enjoyed much of my time trying to participate in volunteering events. Much of my time in high school, I participated in Key Club. Their objective was to help high school students develop leadership skills along with gaining an appreciation for community service. Some events I attended included helping create Thanksgiving baskets at Elmhurst Hospital and making food for "Kids Day" at LaGuardia Airport.
I have continued to pursue volunteering opportunites in Drexel by joining the Campus Activites Board (CAB). Creating marketing materials and working events as a member of CAB has allowed me to continue doing what I love, while raising the spirits of people at the school. Not only that, but by joining the club Dac Pack, I continue my love for sports by cheer on the sidelines for Drexel's basketball teams. Knowing that I can raise spirits up for even a small amount of people brings me joy.


vignettes/functionality_overview.Rmd
functionality_overview.Rmd
Throughout the practical we will use the bioRad R package. It’s currently not (yet) in the default CRAN repository, but can be downloaded from Github. See https://github.com/adokter/bioRad for install instructions. Go through steps 1-3 of these install instructions if you haven’t done so already.
Execute each of the code examples provided below in Rstudio, and try to complete the exercises.
# make sure you start with a fresh R session
# load the bioRad package
library(bioRad)
# check the package version
packageVersion("bioRad")
# make sure you have the latest version (0.3.0). If you have an older version, update as follows:
library(devtools)
devtools::install_github("adokter/bioRad@ecography")
All the functions of the bioRad package have fairly elaborated manual pages, that you can refer to at any moment:
# bring up the package general help page:
?bioRad
In the help window, you can click on each of the links to pull up help pages of specific functions. Click on the Index
link at the bottom of each help page to get an overview of all functions and available manual pages.
Start by making a new directory on your local machine that you will use for this practical
# make a new local directory on your machine where to download data for this practical
# replace the string below with the path of that directory:
HOME <- "your/personal/working/directory/"
# check that the directory exists. If the next statement evaluates to FALSE, something went wrong: the directory does not exist or you didn't specify its path correctly
file.exists(HOME)
# we will make HOME our work directory, the default folder in which R will look
# for files, and where it will output newly generated files.
setwd(HOME)
# Finally, we set the local time zone to UTC, so all plotted time axes will be in UTC
Sys.setenv(TZ = "UTC")
Your R session is now properly set up
To work with US NEXRAD data, bioRad currently require a working installation of Docker (linux / mac) or Docker for Windows (not Docker Toolbox, this is an older implementation of Docker for Windows operating systems that is not supported). If you managed to successfully install Docker, test whether it works
# start your local Docker installation
# we first test whether R can communicate with Docker:
check_docker()
If you get a “Hello from Docker!” welcome message, everything is working.
If you did not manage to install Docker, you will not be able to load NEXRAD data into R at this time, but you will be able to continue the exercises with European radar data that can be loaded without Docker.
US NEXRAD data can be accessed in the Amazon cloud
Let us download this polar volume file for the KPAH radar (Paducah, KY), and store it in your working directory.
If you don’t have a working docker container, you can download this polar volume file, and store it in your working directory. It’s the same file but in a different format (only difference is that it contains only data up to 35 km range)
# let's read in the downloaded volume:
file.in <- "KPAH20171025_040338_V06"
# or in case you downloaded the file that doesn't require docker, the filename is different:
file.in <- "volume.h5"
# check that the file is stored in the right location:
file.exists(file.in)
# load the polar volume:
pvol <- read_pvolfile(file.in)
## print some information about the polar volume
pvol
# print information about the polar scans contained in this polar volume:
pvol$scans
# let's extract the third scan, which was collected at 0.48 degree elevation:
pscan <- pvol$scans[[1]]
# print some information about this scan:
pscan
# before we can plot the scan, we need to project it on a Cartesian grid,
# i.e. we need to make a Plan Position Indicator (PPI)
my_ppi <- project_as_ppi(pscan, cellsize = 1000, range.max = 25000)
# print some information about this ppi:
str(my_ppi)
# you can see we projected it on a 500 metre grid.
# Check the manual of the ppi function to see how you can change the projection
# Now we are ready to plot the ppi
# plot the reflectivity factor image:
plot(my_ppi, param = "VRADH", zlim = c(-30, 30))
# see plot.ppi for all the plot options for a ppi object:
?plot.ppi
# It is often informative to plot radar data on a base layer, such as google earth maps.
# first download the background image:
satelliteImage <- download_basemap(my_ppi, maptype = "satellite")
# then overlay the PPI on the satellite image:
map(my_ppi, param = "DBZH", map = satelliteImage, zlim = c(-20, 15))
# Note that in R, spatial data is often contained in class objects of packag 'sp'
# bioRad also uses these objects in the background, and they can be extracted if you want to.
# The spatial data is stored in the data slot, as in:
my_spatialgrid <- my_ppi$data
# you can use the sp package to save the spatial data to all kinds GIS formats, for example ArcGis:
library(sp)
write.asciigrid(my_spatialgrid, "PPI_in_arcgis_format.asc")
We will generate vertical profiles with the automated algorithm vol2bird (https://github.com/adokter/vol2bird), which is included in the bioRad package. You need a working installation of Docker (linux / mac) or Docker for Windows (not Docker Toolbox, this is an older implementation of Docker for Windows operating systems that is not supported).
# we will process the same file as in section 1.3:
file.in
# check whether the file is still there:
file.exists(file.in)
# run vol2bird
vp <- calculate_vp(file.in, range.max = 35000, sd_vvp = 1, dealias = T, dualpol = T)
# vp is now a 'vp', a vertical profile
vp
# alternatively, you may also store the profile on disk as a hdf5 file, which is what we will do next:
# let's first define the name of the output file (we paste the extention ".h5" to the name)
file.out <- paste(file.in, ".h5", sep = "")
# print the newly generated output file name to which we will write:
# note that this is only a string, you can give it any other name if you want to
file.out
# finally, run vol2bird; this generates an output file as specified in file.out
# we set autoconf to TRUE, to let vol2bird figure out the optimal settings by itself
calculate_vp(file.in, file.out, range.max = 35000, sd_vvp = 1, dealias = T, dualpol = T)
# your work directory should now contain a new file with the name you specified in file.out
# check that we can read this file, and retrieve the vertical profile from it:
vp <- read_vpfiles(file.out)
Now that you have loaded a list of vertical profiles, we can start exploring them. We will start with plotting and inspecting single vertical profiles, i.e. a single profile from the vplist object you have just loaded.
# plot the vertical profile, in terms of reflectivity factor
plot(vp, quantity = "dbz")
# plot the vertical profile, in terms of reflectivity
plot(vp, quantity = "eta")
These two plots look very different, but they are twice the same data plotted on a different scale.
eta = (radar-wavelength dependent constant) * 10^(dbz/10)
So eta
and dbz
are closely related, the main difference is that reflectivity factors are logarithmic, and reflectivities linear.
The reflectivity factor dbz
is the quantity used by most meteorologist. It has the useful property that at different radar wavelengths (e.g. S-band versus C-band) the same amount of precipitation shows up at equal reflectivity factors. The same holds for insects, as well as any other target that is much smaller than the radar wavelength (S-band = 10 cm, C-band = 5 cm), the so-called Rayleigh-scattering limit
In the case of birds we are outside the Rayleigh limit, because birds are of similar size as the radar wavelength. In this case the reflectivity eta
is more similar between S-band and C-band (though might be a little different). eta
is also more directly related to the density of birds, since eta
can be expressed as (bird density) x (radar cross section per bird). For these two reasons, for weather radar ornithologists reflectivity eta
is the more conventional unit (instead of reflectivity factor in dBZ).
# print the currently assumed radar cross section (RCS) per bird:
rcs(vp)
# plot the vertical profile, in terms of bird density
plot(vp, quantity = "dens")
We can change the assumed radar cross section as follows:
# let's change the RCS to 110 cm^2
rcs(vp) <- 110
plot(vp, quantity = "dd")
To save some time, we will continue with some pre-processed vertical profiles for the KPAH radar.
Navigate to https://www.dropbox.com/s/6em8s4yjqutkfle/profiles.zip?dl=0 and download the processed profiles, profiles.zip
.
# unzip the profiles.zip file, either by clicking the file or the command below; after unzipping you should have a folder 'profiles' with processed data
# load all the filenames in the new 'profiles' subfolder in your working directory
vp_paths <- dir("./profiles", recursive = TRUE, full.names = TRUE)
vp_paths
# read these vertical profiles (hdf5 files) into R (may take a minute to load)
vplist <- read_vpfiles(vp_paths)
# print some information on the vplist object. It should contain 71 profiles
vplist
# save the object, which allows you to load the data more quickly next time
save(vplist, file = "vplist.RData")
# you can restore the vplist object at any time as follows:
load("vplist.RData")
We will now examine multiple vertical profiles at once that are ordered into a time series, e.g. the vertical profiles obtained from a single radar over a full day.
# convert the list of vertical profiles into a time series:
# In case your vplist contains profiles of different radars, this function will
# group the profiles and make a separate time-series for each radar.
# (but in our case we have profiles for only one radar)
ts <- vplist_to_vpts(vplist)
# print summary information
ts
# plot the time series in terms of reflectivity factors, from 0-2000 metre altitude:
plot(ts, quantity = "dbz", ylim = c(0, 2000))
# plot the time series in terms of bird density:
plot(ts, quantity = "dens", ylim = c(0, 2000))
# change the radar cross-section works the same as for single vertical profiles, for example:
rcs(ts) <- 20
# check the help file for more plotting options
# Because profile timeseries are of class 'vpts', it's associated plotting function
# is plot.vpts:
?plot.vpts
To interpret the wind barbs in the profile time series figure: each half flag represents 2.5 m/s, each full flag 5 m/s, each pennant (triangle) 25 m/s.
# time series objects can be subsetted, just as you may be used to with vectors
# here we subset the first 50 timesteps:
ts[1:50]
Precipitation is known to have a major influence on the timing and intensity of migration, therefore it can be useful to inspect profiles for presence of precipitation. An easy way of doing that is plotting the vertical profile of total reflectivity (quantity DBZH), which includes everything: birds, insects and precipitation. Precipitation often has higher reflectivities than birds, and also extends to much higher altitudes.
# plot the time series
plot(ts, quantity = "DBZH")
# You can also extract the data from bioRad's class objects into a simple R format:
#
# Extract some data from the time series, e.g. the bird density
get_quantity(ts, quantity = "dens")
# convert all the data in the time series to a standard data.frame:
my_dataframe <- as.data.frame(ts)
my_dataframe
Often you will want to sum together all the migrants in the vertical dimension, for example if you want a single index of how many birds are migrating at a certain instant. There are at least two ways in which you can do that
We will be using bioRad’s integrate_profile
function to calculate these quantities
# Let's continue with the ts object created in the previous example.
# The vertically integrated quantities are calculated as follows:
integrated.ts <- integrate_profile(ts)
# plot the integrated data to screen:
integrated.ts
# The integrated.ts object you created is a vpi class object, which is an acronym for Vertical Profiles Integrated. It has its own plot method, which by default plots migration traffic rate (MTR):
plot(integrated.ts)
# you can also plot vertically integrated densities (VID):
plot(integrated.ts, quantity = "vid")
Now let’s calculate how many birds passed over the radar during the full time series:
# Let's continue with the ts object created in the previous example.
# we can integrate all the traffic rates [unit: birds/km/h] over time, to obtain the number of birds that
# have passed over the radar [unit: birds/km]. Like the traffic rates, these numbers are calculated for
# a 1 km transect perpendicular to the migratory direction, and stored in column mt of the object:
plot(integrated.ts, quantity = "mt")


Hi, my name is Karndeep Singh Kahlon I am 19 year old male living in Kitchener Ontario. I am currently pursuing my dream as developer by going to Conestoga college for IT innovation and design(year three) at this time I am looking for a co-op position to try to enhance my current programming knowledge. I excellence in team environments and have a passion for coding. I feel if you want something to get done you have to get up and get started in coding and in life.I like facing challenging problems and tackle them head on.
The first time I programmed in highschool I knew this was the profession for me. I have never had so much passion and pride for something so little as a flap bird game, so I decide to further develop my skills in college. In addition to my course-based programming assignments, I also enjoy developing programs for my own recreation in open source technologies, and practicing online using Code School.
Boxing has shaped me into the person I am today by teaching me discipline, maturity, and strong work ethic. I enjoy training/coaching with my family club WRBA which is non-profit organizing. I have been apart of the WRBA team for seven years and like to give back to the community by doing charitable events.
I have played rep soccer for the city of kitchener from U9-U21. My favorite player is Michael Ballack because I liked his passing range, powerful shot, physical strength and commanding presence in the midfield. I still enjoy playing the sport in recreation leagues as a hobby.


Welcome! Follow my journey as I navigate the world of web development, with the help of Ensipral Dev Academy.


Page 1 of 1
For this weekend's update
Posted:
Fri Sep 05, 2008 10:16 am
by Karl G.
Hi everyone! This is what I have in mind for this weekend's update:
- Kill that weird monster-spawning lag bug
- Fix monster movement so they attack more intelligently
- Add more kinds of monsters so everyone can have things to fight and the cool items can actually be found
- Hopefully add a safe-square of some kind.
Re: For this weekend's update
Posted:
Fri Sep 05, 2008 11:04 am
by Cagen
Sounds good besides the last point.
Re: For this weekend's update
Posted:
Fri Sep 05, 2008 11:30 am
by Sankt Pauli
What's wrong with a sq? :p
Or do you mean the 'hopefully' part?
Anyways, looking forward to this, imo the spawnlag is the most important issue (having more drops then just wristbands is cool too though, i start to run out of give-away items). :J
Edit: I just read a thread about mirc/vent. How about a global chat in evidyon?
Re: For this weekend's update
Posted:
Fri Sep 05, 2008 1:02 pm
by Cagen
What's wrong with a square?

Global chat would be awesome. Being able to hunt for items is what I am waiting for.
Re: For this weekend's update
Posted:
Fri Sep 05, 2008 1:47 pm
by Sankt Pauli
Let me pk you over and over again while you try to drop junk or equip items and we talk again. :p
Plus i saw a bunch of 'players' that did nothing else but spam hmh on everything that moves at the starting point for hours, a sq is a vital basic addition.
Re: For this weekend's update
Posted:
Fri Sep 05, 2008 3:57 pm
by BLC87
Got to love when their attention is 1 screen away, and you can power walk away. (Love Argent gear <3)
Re: For this weekend's update
Posted:
Fri Sep 05, 2008 5:48 pm
by Cagen
Sankt Pauli wrote:Let me pk you over and over again while you try to drop junk or equip items and we talk again. :p
Plus i saw a bunch of 'players' that did nothing else but spam hmh on everything that moves at the starting point for hours, a sq is a vital basic addition.
 (It's Exo
)
Games are far too care bear, we shouldn't need squares.
Re: For this weekend's update
Posted:
Fri Sep 05, 2008 5:56 pm
by Karl G.
At this point I'm planning one safe zone where people spawn. Everything else will be fair game; however, I played for a little while on an anonymous character and getting killed over and over is a little frustrating.
Oh and by the way: I'm working on a
completely new map that has about 3x more land, arranged in such a way that I can put in more balanced monster types and provide you guys with more variety.
Re: For this weekend's update
Posted:
Fri Sep 05, 2008 6:48 pm
by Joe M.
Sq. at spawn is a must. Nothing worse than spawn-campers, esp. when you're just starting out.
Re: For this weekend's update
Posted:
Fri Sep 05, 2008 8:49 pm
by Karl G.
Ok guys, new map is finished and I've set up incremental monsters from levels 1-2 up to 40.
I don't know how long it will be until release now, though, because I've come up with a way of creating spawn that is a HELL of a lot easier than what I'm using right now and will let me create, update and control the map much more easily. So... I'm going to go ahead and implement that first.
Re: For this weekend's update
Posted:
Sat Sep 06, 2008 8:46 am
by Sankt Pauli
Coolies, that sounds good.
Well i dunno if this is still helpful then:
I noticed the spawn in the 'graveyard' south of the spawning point is still pretty much non-existant (one or two of them strolling around). Sometimes it has full spawn though. Could it be that you have some kind of 'total monsters on map limit' that gets reached before the spawn there is filled up again? Because other places like the monstrosities or the newb areas around starting point have full spawn, and when someone else was on hunting in other areas (reducing the number of monsters) the 'graveyard' had spawn.
My other explanation was that someone logs in a few minutes before me, cleans the place and logs off everytime i'm going there (which seemed not very likely to me).
Re: For this weekend's update
Posted:
Sat Sep 06, 2008 9:05 am
by Karl G.
There is a limit of monsters per region. However, the graveyard on the current map doesn't have a high enough number of monsters.


Eastmatt Supervisor Caught On Camera Brutalising Cashier Pleads Not Guilty To Assault Charges
by WycliffeIbrahim Taraiya, the Eastmatt supermarket supervisor, who was recently caught on camera assaulting a female cashier in Kajiado, has been detained for 10 days.
Taraiya, who was arrested on Saturday, was arraigned on Monday at a Kajiado court where denied assault charges.
The Director of Public Prosecution (DPP) was opposed to Taraiya’s release on bail.
Solomon Njeru, lead counsel for the prosecution, told the court that the man has been threatening the woman, who has since been identified as Sharon Atieno.
Read: Eastmatt Supervisor In Viral Video Re-arrested For Assaulting Female Cashier
The court heard that Taraiya is a flight risk and has been plotting to cross over to Tanzania to escape prosecution.
The case will be mentioned on Friday, December 6.
In the CCTV video that went viral, Taraiya is seen slapping the cashier several times before pulling her by the hair and then hitting her again several times.
The incident angered netizens as it took time before a man restrained Sharon’s assailant.
Read Also: Retailer EastMatt Suspends Supervisor In Viral Video Assaulting Cashier
Eastmatt on Saturday morning issued a statement confirming that the man, who had earlier been identified as a customer, was their employee.
The management said that he had been suspended.
“We as EastMatt condemn and do not stand for such heinous acts of disrespect against out staff more so women. the individual in question acted solely and has since been suspended with a report officially being filed at Kajiado County Police,” read the statement.


| ( * ) [PolyTypes.Math] | Multiplication of two elements |
| ( ** ) [PolyTypes.Math] | Raises an element to the power of an integer value. |
| (&&) [ConstraintTypes.Constraint.Infix] | |
| (&&) [ConstraintTypes.Formula.Infix] | |
| (+) [PolyTypes.Math] | Addition of two elements. |
| (-) [PolyTypes.Math] | Subtraction of two elements. |
| (<) [ConstraintTypes.Constraint.Infix] | |
| (<) [ConstraintTypes.Formula.Infix] | |
| (<) [ConstraintTypes.Atom.Infix] | |
| (<) [PolyTypes.PartialOrder] | Less than comparison of two elements of type t. |
| (<=) [ConstraintTypes.Constraint.Infix] | |
| (<=) [ConstraintTypes.Formula.Infix] | |
| (<=) [ConstraintTypes.Atom.Infix] | |
| (<=) [PolyTypes.PartialOrder] | Less or equal comparison of two elements of type t. |
| (<=>) [ConstraintTypes.Formula.Infix] | |
| (=) [ConstraintTypes.Constraint.Infix] | |
| (=) [ConstraintTypes.Formula.Infix] | |
| (=>) [ConstraintTypes.Formula.Infix] | |
| (=~=) [ConstraintTypes.Constraint] | |
| (=~=) [ConstraintTypes.Atom] | |
| (=~=) [PolyTypes.Ring] | Stable structural compare, but not an actual compare |
| (=~=) [PolyTypes.Evaluable] | |
| (=~=) [PolyTypes.BasePartialOrder] | |
| (=~=) [OurInt] | Comparator for two integers. |
| (=~=) [Var] | TODO doc |
| (>) [ConstraintTypes.Constraint.Infix] | |
| (>) [ConstraintTypes.Formula.Infix] | |
| (>) [ConstraintTypes.Atom.Infix] | |
| (>) [PolyTypes.BasePartialOrder] | Less than comparison of two elements of type t. |
| (>=) [ConstraintTypes.Constraint.Infix] | |
| (>=) [ConstraintTypes.Formula.Infix] | |
| (>=) [ConstraintTypes.Atom.Infix] | |
| (>=) [PolyTypes.PartialOrder] | Greater or equal comparison of two elements of type t. |
| (>>=) [MaybeChanged] | Applies function f on the monad ( |
| (||) [ConstraintTypes.Formula.Infix] | |
| (~-) [PolyTypes.Math] | Negates element. |
| __ocaml_lex_read_rec [Lexer] | |
| __ocaml_lex_tables [Lexer] | |
| _eRR [Parser] | |
| _menhir_discard [Parser] | |
| _menhir_errorcase [Parser] | |
| _menhir_fail [Parser] | |
| _menhir_goto_bound [Parser] | |
| _menhir_goto_constraint_atom [Parser] | |
| _menhir_goto_cost [Parser] | |
| _menhir_goto_formula_atom [Parser] | |
| _menhir_goto_list_ID_ [Parser] | |
| _menhir_goto_loption_separated_nonempty_list_AND_constraint_atom__ [Parser] | |
| _menhir_goto_loption_separated_nonempty_list_AND_formula_atom__ [Parser] | |
| _menhir_goto_loption_separated_nonempty_list_COMMA_ID__ [Parser] | |
| _menhir_goto_loption_separated_nonempty_list_COMMA_polynomial__ [Parser] | |
| _menhir_goto_nonempty_list_transition_ [Parser] | |
| _menhir_goto_onlyAtom [Parser] | |
| _menhir_goto_option_preceded_POW_bound__ [Parser] | |
| _menhir_goto_polynomial [Parser] | |
| _menhir_goto_separated_nonempty_list_AND_constraint_atom_ [Parser] | |
| _menhir_goto_separated_nonempty_list_AND_formula_atom_ [Parser] | |
| _menhir_goto_separated_nonempty_list_COMMA_ID_ [Parser] | |
| _menhir_goto_separated_nonempty_list_COMMA_bound_ [Parser] | |
| _menhir_goto_separated_nonempty_list_COMMA_polynomial_ [Parser] | |
| _menhir_goto_separated_nonempty_list_COMMA_transition_simple_ [Parser] | |
| _menhir_goto_separated_nonempty_list_COMMA_transition_target_ [Parser] | |
| _menhir_goto_separated_nonempty_list_OR_formula_constraint_ [Parser] | |
| _menhir_goto_transition_rhs [Parser] | |
| _menhir_goto_withConstraints [Parser] | |
| _menhir_init [Parser] | |
| _menhir_reduce37 [Parser] | |
| _menhir_reduce41 [Parser] | |
| _menhir_reduce45 [Parser] | |
| _menhir_reduce95 [Parser] | |
| _menhir_reduce97 [Parser] | |
| _menhir_run1 [Parser] | |
| _menhir_run12 [Parser] | |
| _menhir_run136 [Parser] | |
| _menhir_run14 [Parser] | |
| _menhir_run143 [Parser] | |
| _menhir_run145 [Parser] | |
| _menhir_run152 [Parser] | |
| _menhir_run163 [Parser] | |
| _menhir_run165 [Parser] | |
| _menhir_run168 [Parser] | |
| _menhir_run183 [Parser] | |
| _menhir_run185 [Parser] | |
| _menhir_run195 [Parser] | |
| _menhir_run2 [Parser] | |
| _menhir_run3 [Parser] | |
| _menhir_run32 [Parser] | |
| _menhir_run34 [Parser] | |
| _menhir_run35 [Parser] | |
| _menhir_run37 [Parser] | |
| _menhir_run39 [Parser] | |
| _menhir_run4 [Parser] | |
| _menhir_run40 [Parser] | |
| _menhir_run41 [Parser] | |
| _menhir_run42 [Parser] | |
| _menhir_run44 [Parser] | |
| _menhir_run46 [Parser] | |
| _menhir_run48 [Parser] | |
| _menhir_run50 [Parser] | |
| _menhir_run9 [Parser] | |
A | |
| abs [Bound] | Returns for a bound b the new (absolute) bound |b| := max(0,b) + max(0,-b) |
| add [TransitionApproximation] | |
| add [SizeApproximation] | |
| add [SMT.IncrementalZ3Solver] | Asserts the formula. |
| add [PolyTypes.BaseMath] | Returns sum of two element. |
| add_all [SizeApproximation] | |
| add_costbound [Approximation] | |
| add_invariant [ProgramTypes.TransitionGraph] | |
| add_invariant [ProgramTypes.Transition] | |
| add_invariant [Program] | Adds the invariant to the location of the program. |
| add_locations [Program] | |
| add_sizebound [Approximation] | Adds the information that the specified bound is a valid sizebound for the given variable of the transition. |
| add_sizebounds [Approximation] | |
| add_timebound [Approximation] | Adds the information that the specified bound is a valid timebound for the given transition. |
| add_transitions [Program] | |
| affects [Preprocessor] | Returns all the preprocessors that might successfully run after a run of the specific preprocessor. |
| all [Preprocessor] | |
| all [ConstraintTypes.Constraint] | Creates a constraint c1 && ... |
| all [ConstraintTypes.Formula] | Creates a formula (f1 && ... |
| all [Logging] | List of all available loggers |
| all_bounded [TransitionApproximation] | |
| all_strategies [Preprocessor] | |
| all_times_bounded [Approximation] | |
| any [ConstraintTypes.Formula] | Creates a formula (f1 || ... |
| append [TransitionLabel] | Appends the second label to the first label. |
| appr_substitution [Bound] | TODO doc |
| as_bound [LocalSizeBound] | Converts the templated bound to an actual bound. |
| as_formula [LocalSizeBound] | Returns a formula which expresses that the variable is smaller or equal to the bound, e.g. |
| as_substituted_bound [LocalSizeBound] | Takes a function that returns sizebounds for each variable and a local sizebound. |
| asymptotic_complexity [Bound] | Returns an overapproximation of the asymptotic complexity of the given bound. |
| atom_from_apron [InvariantGeneration.Apron2Koat] | Converts an apron atom to its koat equivalent |
| atom_list [ConstraintTypes.Constraint] | Returns the corresponding list of atoms. |
| atom_to_apron [InvariantGeneration.Koat2Apron] | Converts a koat atom to its apron equivalent |
B | |
| bindings [PolyTypes.Valuation] | Returns the var to value bindings. |
| bounded_label_to_string [AnalyseCommand] | |
| bounded_rv_to_string [AnalyseCommand] | |
C | |
| chain [Chaining] | Performs a chaining step removing the location from the graph. |
| chainable [Chaining] | Returns if the specific location is chainable in the graph. |
| changed [MaybeChanged] | Returns the monad ( |
| check_arity [ParserUtil] | |
| check_negativity [SMT.Z3Solver] | |
| check_positivity [SMT.Z3Solver] | |
| coeff [PolyTypes.Polynomial] | Returns the coefficient of the monomial. |
| coeff [PolyTypes.ScaledMonomial] | Returns the constant factor of the scaled monomial. |
| coeff_of_var [ConstraintTypes.Atomizable] | |
| coeff_of_var [PolyTypes.Polynomial] | Returns the coefficient of the term where only the given variable occurs. |
| coeff_of_var [Bound] | Needed for Atomizable but not yet implemented. |
| combinations [VarSet] | TODO doc |
| command [LocalSizeBoundCommand] | |
| command [SizeCommand] | |
| command [PrfCommand] | |
| command [SMTCommand] | |
| command [NormalizeCommand] | |
| command [AnalyseCommand] | |
| compare [Preprocessor] | |
| compare [ProgramTypes.Location] | |
| compare [ConstraintTypes.Constraint] | Stable structural compare, but not an actual compare |
| compare [ConstraintTypes.Atom] | Stable structural compare, but not an actual compare |
| compare [PolyTypes.Ring] | |
| compare [PolyTypes.Evaluable] | Stable structural compare, but not an actual compare |
| compare [Var] | |
| compare_equivalent [ProgramTypes.Transition] | |
| compare_equivalent [RVGTypes.RV] | |
| compare_equivalent [TransitionLabel] | |
| compare_kind [SizeApproximation] | |
| compare_kind [TransitionLabel] | |
| compare_same [ProgramTypes.Transition] | |
| compare_same [RVGTypes.RV] | |
| compare_same [TransitionLabel] | |
| compare_sort [Var] | |
| compute [NontrivialSizeBounds] | Computes a bound for a nontrivial scc. |
| compute [TrivialSizeBounds] | Computes a bound for a trivial scc. |
| compute [TrivialTimeBounds] | This preprocessor infers for all transitions which are not part of an scc a time bound of one. |
| compute_ [NontrivialSizeBounds] | |
| const_from_apron [InvariantGeneration.Apron2Koat] | TODO Usage of OurInt.to_int breaks usage of big_int |
| const_to_apron [InvariantGeneration.Koat2Apron] | TODO Usage of OurInt.to_int breaks usage of big_int |
| constant [LocalSizeBound] | Returns the constant of the local sizebound. |
| constraint_from_apron [InvariantGeneration.Apron2Koat] | Converts a koat constraint to its apron equivalent |
| constraint_to_apron [InvariantGeneration.Koat2Apron] | Converts a koat constraint to its apron equivalent |
| constraints [ConstraintTypes.Formula] | Returns a list of all constraints occuring in the disjunction. |
| cost [Approximation] | |
| cost [ProgramTypes.Transition] | Adds the invariant to this transition. |
| cost [TransitionLabel] | |
| costbound [Approximation] | Returns a costbound for the transition. |
| create [Approximation] | |
| create [SMT.IncrementalZ3Solver] | Creates a new incremental smt solver. |
D | |
| decreasing [RankingFunction] | Returns a non-empty list of all transitions which are strictly decreasing and at the same time bounded with one. |
| default [LocalSizeBound] | |
| default [TransitionLabel] | |
| default_cmd [Main] | |
| default_vars [ParserUtil] | Returns list of default variables: x,y,z,u,v,w,p and q |
| degree [PolyTypes.Evaluable] | Returns the degree of a polynomial. |
| degree_variable [PolyTypes.Monomial] | Returns the degree of the given variable. |
| delete_monomial [PolyTypes.Polynomial] | Removes all summands from the polynomial which are equivalent to the monomial. |
| delete_var [PolyTypes.Monomial] | Deletes all occurences of the given variable. |
| description [LocalSizeBoundCommand] | |
| description [SizeCommand] | |
| description [PrfCommand] | |
| description [SMTCommand] | |
| description [NormalizeCommand] | |
| description [AnalyseCommand] | |
| drop_nonlinear [Constraints.Constraint] | Drops all nonlinear atoms from the constraints. |
| drop_nonlinear [ConstraintTypes.Constraint] | Drops all nonlinear atoms from the constraints. |
| dualise [Constraints.Constraint] | TODO doc |
| dualise [ConstraintTypes.Constraint] | TODO doc |
E | |
| empty [Approximation] | Returns an empty approximation that does not contain any non-trivial information. |
| empty [TransitionApproximation] | |
| empty [SizeApproximation] | |
| entry_points [RVGTypes.RVG] | Returns all the entry points of the SCC. |
| enum_to_string [Util] | |
| equal [Preprocessor] | |
| equal [LocalSizeBound] | Returns if the templated bounds represent the same bound. |
| equal [ProgramTypes.Location] | |
| equal [ConstraintTypes.Constraint] | Stable structural equality, but not an actual equality |
| equal [ConstraintTypes.Atom] | Stable structural equality, but not an actual equality |
| equal [PolyTypes.Ring] | |
| equal [PolyTypes.Evaluable] | Stable structural equality, but not actual equality |
| equal [Var] | |
| equal_complexity [Bound] | TODO doc where is this method? Returns true iff. |
| equal_kind [SizeApproximation] | |
| equal_kind [TransitionLabel] | |
| equal_sort [Var] | |
| equivalent [Approximation] | |
| equivalent [TransitionApproximation] | |
| equivalent [SizeApproximation] | |
| equivalent [ProgramTypes.TransitionGraph] | Replaces the first edge by the second edge. |
| equivalent [ProgramTypes.Transition] | |
| equivalent [RVGTypes.RV] | |
| equivalent [Program] | |
| equivalent [TransitionLabel] | Returns if the two labels describe the same transition |
| equivalent [SMT.Z3Solver] | |
| eval [PolyTypes.Evaluable] | Assigns each variable inside the polynomial the value of the valuation and returns the arithmetically computed result. |
| eval [PolyTypes.Valuation] | Returns the value of the variable. |
| eval_coefficients [Polynomials.ParameterPolynomial] | Evaluates coefficients (which are polynomials over |
| eval_f [PolyTypes.Evaluable] | Assigns each variable inside the polynomial the value of the evaluated function and returns the arithmetically computed result. |
| eval_opt [PolyTypes.Valuation] | Returns the value of the variable, if the valuation defines one for it. |
| eval_partial [PolyTypes.Polynomial] | Creates a polynomial where every variable for which a value is assigned by the valuation is replaced by this value. |
| exp [Bound] | Returns for a positive integer OurInt i and a bound b the new bound b^i. |
F | |
| factor [LocalSizeBound] | Returns the factor of the local sizebound. |
| farkas_transform [Constraints.ParameterConstraint] | Applies Farkas-Transformation on a Constraint and a ParameterAtom. |
| find [RankingFunction] | Finds a suitable ranking function for the given transitions T'. |
| find [RenameMap] | Returns the new name of the variable or a default value, if the rename map does not assign a new name to the variable |
| find_bound [LocalSizeBound] | Tries to find a templated bound of any of the defined templates. |
| find_bounds [Bounds] | |
| find_bounds_ [Bounds] | |
| find_map [Util] | |
| flat_map [MaybeChanged] | Applies function f on the monad ( |
| flatten [Polynomials.ParameterPolynomial] | Transforms the template polynomial such that all inner values get lifted to the outer polynomial. |
| fold [ConstraintTypes.Constraint] | Replaces all operations by new constructors. |
| fold [ConstraintTypes.Formula] | Replaces all operations by new constructors. |
| fold [ConstraintTypes.Atom] | Replaces all operations by new constructors. |
| fold [PolyTypes.Polynomial] | Replaces all arithmetical operations by new constructors. |
| fold [PolyTypes.Monomial] | Replaces all arithmetical operations by new constructors. |
| fold [Bound] | Replaces all arithmetical operations by new constructors. |
| fold [PolyTypes.ScaledMonomial] | Replaces all arithmetical operations by new constructors. |
| fold_enum [MaybeChanged] | TODO doc |
| fresh_arg_list [Var] | Returns a bunch of fresh arg ids. |
| fresh_id [Var] | Returns a not yet used id, which is guaranteed to be distinct from any yet existing ids. |
| fresh_id_list [Var] | Returns a bunch of fresh ids. |
| fresh_ids [Var] | Returns a bunch of fresh ids. |
| from [Program] | |
| from [PolyTypes.Valuation] | Creates a valuation from variables to values. |
| from [RenameMap] | Creates a rename map from a two variable association list |
| from_native [PolyTypes.Valuation] | Creates a valuation from a string (var) to int (value) association list. |
| from_native [RenameMap] | Creates a rename map from a two strings (vars) association list |
G | |
| get [TransitionApproximation] | |
| get [SizeApproximation] | |
| get [Logging] | |
| get_all [Util] | Returns None if one of the optionals evaluates to None. |
| get_coefficient [Atoms.ParameterAtom] | Returns the coefficient of a variable which is normalised to the lhs. |
| get_coefficient [ConstraintTypes.Atom] | Returns the coefficient of a variable which is normalised to the lhs. |
| get_coefficient_vector [Constraints.ParameterConstraint] | Returns the row of all coefficients of a variable in a constraint, i.e., used for farkas quantor elimination. |
| get_coefficient_vector [Constraints.Constraint] | Returns the row of all coefficients of a variable in a constraint, i.e., used for farkas quantor elimination. |
| get_coefficient_vector [ConstraintTypes.Constraint] | Returns the row of all coefficients of a variable in a constraint, i.e., used for farkas quantor elimination. |
| get_constant [Atoms.ParameterAtom] | Returns the single right hand side constant of the atom. |
| get_constant [ConstraintTypes.Atomizable] | |
| get_constant [ConstraintTypes.Atom] | Returns the single right hand side constant of the atom. |
| get_constant [PolyTypes.Polynomial] | Returns the constant of the polynomial. |
| get_constant [Bound] | Returns the constant of a bound |
| get_constant_vector [Constraints.ParameterConstraint] | Returns the row of all constants in a constraint, i.e., used for farkas quantor elimination. |
| get_constant_vector [Constraints.Constraint] | Returns the row of all constants in a constraint, i.e., used for farkas quantor elimination. |
| get_constant_vector [ConstraintTypes.Constraint] | Returns the row of all constants in a constraint, i.e., used for farkas quantor elimination. |
| get_id [TransitionApproximation] | |
| get_lsb [AnalyseCommand] | |
| get_matrix [Constraints.ParameterConstraint] | Returns the matrix of all coefficients of a variable from a set of variables in a constraint, i.e., used for farkas quantor elimination. |
| get_matrix [Constraints.Constraint] | Returns the matrix of all coefficients of a variable from a set of variables in a constraint, i.e., used for farkas quantor elimination. |
| get_matrix [ConstraintTypes.Constraint] | Returns the matrix of all coefficients of a variable from a set of variables in a constraint, i.e., used for farkas quantor elimination. |
| get_model [SMT.Z3Solver] | |
| graph [Program] | |
| guard [TransitionLabel] | |
| guard_to_string [TransitionLabel] | |
H | |
| has_changed [MaybeChanged] | Returns true iff. |
| hash [ProgramTypes.Transition] | |
| hash [ProgramTypes.Location] | |
| hash [RVGTypes.RV] | |
| hash [Var] | TODO doc |
| hash [Util] | Generates a hash interger value of a given string. |
| html_body [ProofOutput] | |
| html_header [ProofOutput] | |
I | |
| id [ProgramTypes.Transition] | |
| id [TransitionLabel] | |
| id [RenameMap] | Creates a rename map where every variable keeps its name |
| if_changed [MaybeChanged] | Applies function f on the monad ( |
| implies [ConstraintTypes.Formula] | Returns for two formulas f,g the the formula f -> g |
| improve [RankingBounds] | Performs a single improvement step to find better timebounds for the approximation and updates the approximation. |
| improve [SizeBounds] | Performs a single improvement step for a whole program to find better sizebounds for the approximation and updates the approximation. |
| improve_scc [SizeBounds] | Performs a single improvement step for a single scc to find better sizebounds for the approximation and updates the approximation. |
| incoming_bound [TrivialSizeBounds] | Returns the maximum of all incoming sizebounds applied to the local sizebound. |
| infer_from_timebounds [CostBounds] | |
| infinity [Bound] | Returns the infinity bound. |
| input_size [TransitionLabel] | |
| input_vars [Program] | |
| input_vars [TransitionLabel] | Returns the set of input variables of the transition, i.e. |
| instantiate [PolyTypes.Polynomial] | Maps all coefficients to elements from the polynomial. |
| int_helper [PolyTypes.Polynomial] | TODO doc |
| intersection [Util] | Computes the intersection between both enums with the given equality function. |
| is_const [PolyTypes.Polynomial] | Returns if the value of the polynomial is not be affected by any variable. |
| is_defined [PolyTypes.Valuation] | Returns true if variable is defined. |
| is_finite_bound [LocalSizeBound] | Returns true if the given local size bound is an actual bound and false, if the local size bound is infinity or -infinity |
| is_helper [Var] | Returns true if variable has type |
| is_infinity [Bound] | Returns true iff. |
| is_initial [Program] | Returns if the given transition is an initial transition. |
| is_initial_location [Program] | Returns if the given transition is an initial transition. |
| is_linear [ConstraintTypes.Atomizable] | |
| is_linear [ConstraintTypes.Atom] | Returns if both polynomials are linear. |
| is_linear [PolyTypes.Polynomial] | Returns if the polynomial is linear. |
| is_linear [Bound] | Returns true iff the asymptotic complexity is n^1. |
| is_minus_infinity [Bound] | Returns true iff. |
| is_one [PolyTypes.Polynomial] | Returns if the value of the polynomial is the constant value one (1). |
| is_real [Var] | Returns true if variable is ranged over real numbers. |
| is_sum_of_vars_plus_constant [PolyTypes.Polynomial] | Returns if the polynomial is equivalent to a term x_1^1 + ... |
| is_time_bounded [Approximation] | |
| is_true [ConstraintTypes.Constraint] | Returns if the constraint is a tautology. |
| is_univariate_linear [PolyTypes.Polynomial] | Returns if the polyomial is linear and contains at most one active variable. |
| is_univariate_linear [PolyTypes.Monomial] | Returns if the monomial is of the simplified form x^1 for any variable x. |
| is_var [PolyTypes.Polynomial] | Returns if the polynomial is equivalent to a term x^1 for any variable x. |
| is_var_plus_constant [PolyTypes.Polynomial] | Returns if the polynomial is equivalent to a term x^1 + c for any variable x and any constant c. |
| is_zero [PolyTypes.Polynomial] | Returns if the value of the polynomial is the constant value zero (0). |
L | |
| label [ProgramTypes.Transition] | |
| le_than_all [ConstraintTypes.Formula] | Returns the formula (p <= p1 && ... |
| le_than_any [ConstraintTypes.Formula] | Returns the formula (p <= p1 || ... |
| lift [ConstraintTypes.Constraint] | Lifts an atom to a constraint, i.e., a single atom a is a constraint [a] as a constraint is a conjunction over atoms. |
| lift [ConstraintTypes.Formula] | Lifts an atom to a formula, i.e., a single atom a is a formula [[a]] as a formula is a disjunction over constraints. |
| lift [PolyTypes.Polynomial] | Lifts a monomial and an integer coefficient to a polynomial. |
| lift [PolyTypes.Monomial] | Creates a monomial from a variable and a exponent. |
| lift [PolyTypes.ScaledMonomial] | Lifts a monomial to a scaled monomial with the constant factor one. |
| lift_to_program [Preprocessor] | |
| lift_to_tuple [Preprocessor] | |
| loc_transitions [ProgramTypes.TransitionGraph] | |
| location_table [ParserUtil] | |
| locations [ProgramTypes.TransitionGraph] | |
| locations [Program] | Returns all locations which occur in the transitions, but each location only once. |
| logger [CutUnreachableLocations] | |
| logger [CutUnsatisfiableTransitions] | |
| logger [Chaining] | |
| logger [InvariantGeneration] | |
| logger [NontrivialSizeBounds] | |
| logger [TrivialSizeBounds] | |
| loggers [Logging] | List of all available loggers |
M | |
| main_params_cmdliner_term [Main] | |
| make [TransitionLabel] | |
| make [PolyTypes.Polynomial] | Creates a polynomial as the sum of a list of monomials and integer coefficients. |
| make [PolyTypes.Monomial] | Creates a monomial from a list of variables and their exponents. |
| make [PolyTypes.ScaledMonomial] | Creates a scaled monomial from a monomial and constant factor. |
| map [MaybeChanged] | Applies function f on the monad ( |
| map_graph [Program] | |
| map_guard [TransitionLabel] | Returns a new transition label with the guard changed. |
| map_polynomial [ConstraintTypes.Constraint] | TODO doc |
| map_polynomial [ConstraintTypes.Formula] | TODO doc |
| map_to_array [VarSet] | TODO doc |
| map_to_list [VarSet] | TODO doc |
| map_to_set [VarSet] | TODO doc |
| max [OurInt] | Returns maximum of first and second integer. |
| max [Bound] | Returns for two bounds p,q the maximum bound max(p,q). |
| max_of_occurring_constants [Constraints.Constraint] | TODO doc |
| max_of_occurring_constants [Formulas.Formula] | TODO doc |
| max_of_occurring_constants [Atoms.Atom] | TODO doc |
| max_of_occurring_constants [Polynomials.Polynomial] | TODO doc |
| max_of_occurring_constants [Bound] | Returns for a polynomial bound the maximal occuring constant. |
| max_option [Util] | Computes the maximum of the enum if non-empty, else returns None. |
| maximize [SMT.IncrementalZ3Solver] | Maximizes the variable. |
| maximum [Bound] | Returns a bound representing the maximum of all the values. |
| memoize [Util] | |
| min [OurInt] | Returns minimum of first and second integer. |
| min [Bound] | Returns for two bounds p,q the minimum bound min(p,q). |
| min_option [Util] | Computes the maximum of the enum if non-empty, else returns None. |
| minimize [SMT.IncrementalZ3Solver] | Minimizes the variable. |
| minimize_absolute [SMT.IncrementalZ3Solver] | Sets the variables, which absolute value should be minimized. |
| minimum [Bound] | Returns a bound representing the minimum of all the values. |
| minus_infinity [Bound] | Returns the negative infinity bound. |
| mk [LocalSizeBound] | Creates a templated bound from the template and a string list which represents the variable set. |
| mk [Program] | |
| mk [TransitionLabel] | |
| mk [ConstraintTypes.Constraint] | Creates a constraint from a set of atoms. |
| mk [ConstraintTypes.Formula] | Creates a formula from a set of constraints. |
| mk [ConstraintTypes.Atom] | Makes an atom out of two objects and a comparator. |
| mk_and [ConstraintTypes.Constraint] | Creates a new constraint as the conjunction of the atoms from two given constraints. |
| mk_and [ConstraintTypes.Formula] | Returns the (normalized) conjunction of two formulas. |
| mk_eq [ConstraintTypes.Constraint] | Creates a constraint that expresses the equality of the two polynomials. |
| mk_eq [ConstraintTypes.Formula] | Creates a formula that expresses the equality of the two polynomials. |
| mk_ge [ConstraintTypes.Constraint] | Creates a constraint that expresses for two polynomials p and q the comparision p >= q. |
| mk_ge [ConstraintTypes.Formula] | Creates a formula that expresses for two polynomials p and q the comparision p >= q. |
| mk_ge [ConstraintTypes.Atom] | Makes an atom out of two objects using >= as the comparator. |
| mk_gt [ConstraintTypes.Constraint] | Creates a constraint that expresses for two polynomials p and q the comparision p > q. |
| mk_gt [ConstraintTypes.Formula] | Creates a formula that expresses for two polynomials p and q the comparision p > q. |
| mk_gt [ConstraintTypes.Atom] | Makes an atom out of two objects using > as the comparator. |
| mk_helper [Var] | Creates a helper variable of type |
| mk_le [ConstraintTypes.Constraint] | Creates a constraint that expresses for two polynomials p and q the comparision p <= q. |
| mk_le [ConstraintTypes.Formula] | Creates a formula that expresses for two polynomials p and q the comparision p <= q. |
| mk_le [ConstraintTypes.Atom] | Makes an atom out of two objects using <= as the comparator. |
| mk_lt [ConstraintTypes.Constraint] | Creates a constraint that expresses for two polynomials p and q the comparision p < q. |
| mk_lt [ConstraintTypes.Formula] | Creates a formula that expresses for two polynomials p and q the comparision p < q. |
| mk_lt [ConstraintTypes.Atom] | Makes an atom out of two objects using < as the comparator. |
| mk_or [ConstraintTypes.Formula] | Returns the disjunction of two formulas. |
| mk_program [ParserUtil] | Returns a program corresponding to the given list of transition with a fixed start location. |
| mk_program_simple [ParserUtil] | Input is not interpreted as a filepath, but as a program in simple mode. |
| mk_transition [ParserUtil] | Generates transitions from given parameters |
| mk_transition_simple [ParserUtil] | Input is not interpreted as a filepath, but as a program in simple mode. |
| mk_true [ConstraintTypes.Constraint] | Creates the trivial constraint true, i.e., []. |
| mk_true [ConstraintTypes.Formula] | Creates the trivial formula true, i.e., |
| mk_uneq [ConstraintTypes.Formula] | Creates a formula that expresses the unequality of the two polynomials. |
| model [SMT.IncrementalZ3Solver] | Returns a model of the current state, if the state is satisfiable. |
| monomial [PolyTypes.ScaledMonomial] | Returns the normalized scaled monomial, i.e., the monomial part of the scaled monomial. |
| monomials [PolyTypes.Polynomial] | Returns the monomials of the polynomial without the empty monomial. |
| mul [PolyTypes.BaseMath] | Returns product of two element. |
| mul [PolyTypes.Monomial] | Multiplies two monomials. |
| mul [PolyTypes.ScaledMonomial] | Multiplies two scaled monomials. |
| mult_with_const [PolyTypes.Polynomial] | Multiplies the polynomial with a constant value. |
| mult_with_const [PolyTypes.ScaledMonomial] | Multiplies a scaled monomial with a constant factor. |
N | |
| neg [ConstraintTypes.Formula] | Returns the negated formula. |
| neg [ConstraintTypes.Atom] | Returns the negation of an atom. |
| neg [PolyTypes.BaseMath] | Returns negated element. |
| next_line [Lexer] | |
| non_increasing [RankingFunction] | Returns a list of all transitions for which the prf is defined. |
| non_trivial_transitions [Program] | Returns all transitions, that belong to an SCC. |
| normalised_lhs [ConstraintTypes.Atom] | Returns a normalised form of the atom, where the returned polynomial represents the atom in the form p <= 0. |
O | |
| of_coeff_list [ConstraintTypes.Atomizable] | |
| of_coeff_list [PolyTypes.Polynomial] | Creates a polynomial from a coefficient list and a corresponding variable list. |
| of_coeff_list [Bound] | Needed for Atomizable but not yet implemented. |
| of_constant [ConstraintTypes.Atomizable] | |
| of_constant [PolyTypes.Polynomial] | Lifts a constant to a polynomial. |
| of_constant [Bound] | Creates a constant bound from a constant OurInt. |
| of_int [PolyTypes.Ring] | Creates an element of the ring from an integer value. |
| of_int [Bound] | Creates a constant bound from an integer. |
| of_monomial [PolyTypes.Polynomial] | Lifts a monomial to a polynomial |
| of_poly [Bound] | Creates a bound from a polynomial over OutInt. |
| of_polynomial [Polynomials.ParameterPolynomial] | Lifts a polynomial to a parameter polynomial such that the inner structure is kept. |
| of_power [PolyTypes.Polynomial] | Lifts a variable to the power of an intger value to a polynomial. |
| of_scaled [PolyTypes.Polynomial] | Creates a polynomial as the sum of a list of scaled monomials. |
| of_string [ProgramTypes.Location] | |
| of_string [Var] | Creates a variable from a string. |
| of_string_list [VarSet] | Creates a set of variables from a list of strings. |
| of_var [ConstraintTypes.Atomizable] | |
| of_var [PolyTypes.Polynomial] | Lifts a variable to a polynomial. |
| of_var [Bound] | Creates a bound from a Variable. |
| of_var_string [Bound] | Creates a bound of a string representing a variable. |
| one [PolyTypes.BaseMath] | Returns one element. |
| one [PolyTypes.Monomial] | Returns a monomial representing the numeric value one (1). |
| one [PolyTypes.ScaledMonomial] | Returns the constant (and neutral with multiplication) scaled monomial one. |
| onlyAtom [Parser] | |
| onlyBound [Parser] | |
| onlyConstraints [Parser] | |
| onlyFormula [Parser] | |
| onlyPolynomial [Parser] | |
| onlyProgram [Parser] | |
| onlyProgram_simple [Parser] | |
| only_rank_to_string [RankingFunction] | |
| option_to_string [Util] | |
P | |
| params_cmdliner_term [LocalSizeBoundCommand] | |
| params_cmdliner_term [SizeCommand] | |
| params_cmdliner_term [PrfCommand] | |
| params_cmdliner_term [SMTCommand] | |
| params_cmdliner_term [NormalizeCommand] | |
| params_cmdliner_term [AnalyseCommand] | |
| poly_from_apron [InvariantGeneration.Apron2Koat] | Converts an apron polynomial to its koat equivalent. |
| poly_to_apron [InvariantGeneration.Koat2Apron] | Converts a koat polynomial to its apron equivalent. |
| pop [SMT.IncrementalZ3Solver] | Backtrack one backtracking point. |
| pow [PolyTypes.BaseMath] | Returns element to the power of some provided integer value. |
| pow [OurInt] | Calculates i^n. |
| powerset [ProgramTypes.TransitionSet] | |
| powerset [VarSet] | TODO doc |
| powerset [Util] | |
| pp_kind [NontrivialSizeBounds] | |
| pp_kind [TrivialSizeBounds] | |
| pp_kind [SizeApproximation] | |
| pp_measure [RankingFunction] | |
| pp_params [LocalSizeBoundCommand] | |
| pp_params [SizeCommand] | |
| pp_params [PrfCommand] | |
| pp_params [SMTCommand] | |
| pp_sign [NontrivialSizeBounds] | |
| pre [RVGTypes.RVG] | |
| pre [Program] | Returns a set of all transitions which occur directly before the given transition in the graph. |
| pre_kind [LocalSizeBound] | |
| print_all_bounds [ProofOutput] | Prints the whole resulting approximation to the shell. |
| print_graph [GraphPrint] | |
| print_overall_timebound [ProofOutput] | Prints the overall timebound of the program to the shell. |
| print_rvg [GraphPrint] | Prints a png file in the given directory with the given filename (the extension .png will be generated) for the result variable graph of the program. |
| print_system [GraphPrint] | Prints a png file in the given directory with the given filename (the extension .png will be generated) for the transition graph of the program. |
| print_termcomp [ProofOutput] | Prints only the overall asymptotic timebound of the program to the shell. |
| process [Preprocessor] | Uses the strategy to preprocess the given subject with the specified preprocessors. |
| process_only_once [Preprocessor] | Applies each preprocessor exactly one time on the subject. |
| process_til_fixpoint [Preprocessor] | Applies the preprocessors continously until a fixpoint is reached, such that no preprocessor is able to do another successful preprocessing step. |
| product [PolyTypes.Math] | Returns the product of all enums elements. |
| product [PolyTypes.MakeMath] | Returns the product of all enums elements. |
| program_costbound [Approximation] | Returns a costbound for the program. |
| program_timebound [Approximation] | Returns a timebound for the program. |
| push [SMT.IncrementalZ3Solver] | Creates a backtracking point. |
R | |
| rank [RankingFunction] | Returns the ranking polynomial for the specific location. |
| reachable_locations [CutUnreachableLocations] | Returns a set of all locations which are reachable from the given start location. |
| read [Lexer] | |
| read_atom [Readers] | |
| read_bound [Readers] | |
| read_constraint [Readers] | |
| read_file [Readers] | Reads a file associated to the given path and returns a program. |
| read_formula [Readers] | |
| read_input [MainUtil] | |
| read_input [Readers] | |
| read_polynomial [Readers] | |
| read_program [Readers] | |
| read_program_simple [Readers] | |
| real_helper [PolyTypes.Polynomial] | TODO doc |
| remove_location [Program] | Removes the location from the program and all edges to it. |
| remove_transition [Program] | |
| rename [ProgramTypes.Transition] | |
| rename [Program] | |
| rename [TransitionLabel] | |
| rename [ConstraintTypes.Constraint] | Assigns the variables of the constraint new names based on the rename map |
| rename [ConstraintTypes.Formula] | Assigns the variables of the constraint new names based on the rename map |
| rename [ConstraintTypes.Atomizable] | |
| rename [ConstraintTypes.Atom] | Assigns the variables of the atom new names based on the rename map. |
| rename [PolyTypes.Evaluable] | Assigns the variables of the evaluable new names based on the rename map. |
| rename_graph [AnalyseCommand] | |
| rename_program [AnalyseCommand] | |
| rename_program_option [AnalyseCommand] | |
| replace_edge_e [ProgramTypes.TransitionGraph] | Adds the invariant to the location of the graph. |
| reset [RankingFunction] | Resets all cached data. |
| reset [LocalSizeBound] | Resets all cached data. |
| return [MaybeChanged] | Returns the monad ( |
| run [LocalSizeBoundCommand] | |
| run [SizeCommand] | |
| run [PrfCommand] | |
| run [SMTCommand] | |
| run [NormalizeCommand] | |
| run [AnalyseCommand] | |
| rvg [RVGTypes.RVG] | |
| rvs_to_id_string [RVGTypes.RVG] | |
S | |
| same [ProgramTypes.Transition] | |
| same [RVGTypes.RV] | |
| same [TransitionLabel] | Returns if the two labels are the same entity. |
| same [MaybeChanged] | Returns the monad ( |
| satisfiable [SMT.IncrementalZ3Solver] | Checks if the current state is satisfiable. |
| satisfiable [SMT.Z3Solver] | |
| sccs [Program] | |
| separate_by_sign [Polynomials.Polynomial] | Separates polynomial into a two list. |
| show [Preprocessor] | |
| show [Bound] | Generates a string from a bound and adds the asymptotic complexity if parameter complexity is not assigned to false. |
| show_complexity [Bound] | Returns string representing asymptotic complexity class. |
| show_complexity_termcomp [Bound] | Returns string representing asymptotic complexity class in the TermComp format. |
| show_kind [NontrivialSizeBounds] | |
| show_kind [TrivialSizeBounds] | |
| show_kind [SizeApproximation] | |
| show_logger [Logging] | Returns a string matching to the given logger. |
| show_measure [RankingFunction] | |
| show_params [LocalSizeBoundCommand] | |
| show_params [SizeCommand] | |
| show_params [PrfCommand] | |
| show_params [SMTCommand] | |
| show_sign [NontrivialSizeBounds] | |
| sign [NontrivialSizeBounds] | |
| simplify [PolyTypes.Polynomial] | Returns a simplified version of the polynomial. |
| size [Approximation] | |
| sizebound [Approximation] | Returns a sizebound of the specified kind for the var of the transition. |
| sizebound_local [LocalSizeBound] | Returns a local sizebound of the specified kind for the variable of the transition. |
| sizebound_local_rv [LocalSizeBound] | |
| sizebound_local_scc [LocalSizeBound] | If for all result variables of the given kind a local sizebound is defined, this function returns a local sizebound function. |
| skip_location [Chaining] | Adds transitions to the graph such that every predecessor of the location is correctly connected with every successor of the location, making the location obsolete. |
| sorted_combinations [VarSet] | TODO doc |
| src [ProgramTypes.Transition] | |
| standard_vars [AnalyseCommand] | |
| start [Program] | |
| str_values [ConstraintTypes.Atom.Comparator] | Returns a list of all possible comparators with their string representation. |
| sub [ConstraintTypes.Atomizable] | |
| sub [PolyTypes.Math] | Subtracts the second element from the first one. |
| sub [PolyTypes.MakeMath] | Subtracts the second element from the first one. |
| subcommand [Main] | |
| subcommands [Main] | |
| substitute [PolyTypes.Polynomial] | Substitutes every occurrence of the variable in the polynomial by the replacement polynomial. |
| substitute [Bound] | Substitutes every occurrence of the variable in the polynomial by the replacement polynomial. |
| substitute_all [PolyTypes.Polynomial] | Substitutes every occurrence of the variables in the polynomial by the corresponding replacement polynomial. |
| substitute_all [Bound] | Substitutes every occurrence of the variables in the polynomial by the corresponding replacement polynomial. |
| substitute_f [PolyTypes.Polynomial] | Substitutes every occurrence of the variables in the polynomial by the corresponding replacement polynomial. |
| substitute_f [Bound] | Substitutes every occurrence of the variables in the polynomial by the corresponding replacement polynomial. |
| sum [TransitionApproximation] | Returns a timebound of the specified kind for the execution of the whole graph. |
| sum [PolyTypes.Math] | Returns the sum of all enums elements. |
| sum [PolyTypes.MakeMath] | Returns the sum of all enums elements. |
T | |
| target [ProgramTypes.Transition] | |
| tautology [SMT.Z3Solver] | |
| time [Approximation] | |
| timebound [Approximation] | Returns a timebound for the transition. |
| timebound_id [Approximation] | Returns a timebound for the transition id. |
| to_id_string [ProgramTypes.Transition] | |
| to_id_string [RVGTypes.RV] | |
| to_id_string [TransitionLabel] | |
| to_int [PolyTypes.Ring] | Returns a ring element interpreted as an integer value. |
| to_int [Bound] | Transforms a bound into an integer. |
| to_simple_string [Program] | |
| to_string [Approximation] | |
| to_string [RankingFunction] | Converts a ranking function into a string |
| to_string [TransitionApproximation] | |
| to_string [SizeApproximation] | |
| to_string [LocalSizeBound] | Converts the templated bound to a string. |
| to_string [ProgramTypes.TransitionSet] | |
| to_string [ProgramTypes.Transition] | |
| to_string [ProgramTypes.Location] | |
| to_string [Program] | |
| to_string [TransitionLabel] | |
| to_string [ConstraintTypes.Constraint] | Returns a string representing the constraint. |
| to_string [ConstraintTypes.Formula] | Returns a string representing the constraint. |
| to_string [ConstraintTypes.Atom.Comparator] | Returns string representing comparator. |
| to_string [ConstraintTypes.Atom] | Returns a string representing the atom. |
| to_string [PolyTypes.Polynomial] | Returns a string representing the polynomial. |
| to_string [PolyTypes.Ring] | Returns a string representing an element. |
| to_string [PolyTypes.Evaluable] | Returns a string representing the evaluation. |
| to_string [PolyTypes.Valuation] | Converts the valuation into a string using the print function. |
| to_string [VarSet] | Returns a string representing a set of variables. |
| to_string [Bound] | Creates a string representing the bound by calling show with complexity enabled. |
| to_string [Var] | Returns a string representing the variable( |
| to_string_to_file [PolyTypes.Polynomial] | Returns a string representing polynomial with less special characters. |
| transform [Preprocessor] | Transforms a preprocessing step with the specific preprocessor on the subject. |
| transform_graph [Chaining] | |
| transform_program [CutUnreachableLocations] | |
| transform_program [CutUnsatisfiableTransitions] | |
| transform_program [InvariantGeneration] | |
| transition [RVGTypes.RV] | |
| transitions [ProgramTypes.TransitionGraph] | |
| transitions [RVGTypes.RVG] | Returns all transitions that are used in the SCC of the RVG. |
| transitions [Program] | |
| turn [ConstraintTypes.Constraint] | Negates every atom of the constraint. |
| turn [ConstraintTypes.Formula] | Negates every atom of every constraint of the formula. |
U | |
| unbounded [CostBounds] | |
| unpack [MaybeChanged] | Returns the object itself without the monad structure. |
| unreachable_locations [CutUnreachableLocations] | |
| unsatisfiable [SMT.IncrementalZ3Solver] | Checks if the current state is satisfiable. |
| unsatisfiable [SMT.Z3Solver] | |
| unsatisfiable_transitions [CutUnsatisfiableTransitions] | |
| update [TransitionLabel] | |
| update_to_string_lhs [TransitionLabel] | |
| update_to_string_rhs [TransitionLabel] | |
| use_loggers [Logging] | |
V | |
| value [PolyTypes.Polynomial] | Lifts an integer value to a polynomial. |
| values [ConstraintTypes.Atom.Comparator] | Returns a list of all possible comparators. |
| var [PolyTypes.Polynomial] | Lifts a variable to a polynomial. |
| var_from_apron [InvariantGeneration.Apron2Koat] | Converts an apron variable to its koat equivalent. |
| var_to_apron [InvariantGeneration.Koat2Apron] | Converts a koat variable to its apron equivalent. |
| variable [RVGTypes.RV] | |
| vars [LocalSizeBound] | Returns a set of of variables which affect the local sizebound |
| vars [Program] | |
| vars [TransitionLabel] | |
| vars [ConstraintTypes.Constraint] | Returns the set of variables which are active in the constraint. |
| vars [ConstraintTypes.Formula] | Returns the set of variables which are active in the formula. |
| vars [ConstraintTypes.Atomizable] | |
| vars [ConstraintTypes.Atom] | Returns the set of variables which are active in the atom. |
| vars [PolyTypes.Evaluable] | Returns a set of the variables which occur in the evaluable |
| vars [PolyTypes.Valuation] | Returns a list of the variables for which the valuation is defined. |
| vars_from_apron [InvariantGeneration.Apron2Koat] | Converts an apron variable set to its koat equivalent. |
| vars_of_purity [LocalSizeBound] | |
| vars_of_sign [LocalSizeBound] | Those are variables with a positive coefficient or a negative coefficient. |
| vars_to_apron [InvariantGeneration.Koat2Apron] | Converts a koat variable set to its apron equivalent. |
W | |
| with_disabled_loggers [Logging] | |
| without [Util] | Returns an enum that contains all elements that are present in the second enum but not in the first enum. |
Z | |
| zero [PolyTypes.BaseMath] | Returns zero element. |
| zero [PolyTypes.Valuation] | Creates a valuation where every variable is assigned the value zero. |


Alessandra Lima IT 162 Portal
Hello! I'm Alessandra.
I was born and raised in the Amazon – Brazil! Yes, I love nature. Besides that, I’m also very interested in learning and experiencing a bit of everything that this world has to offer. I love to visit museums, historical places, and I watch games in the stadium. I love water sports such as swimming, snorkeling, and kayaking; and regardless of the weather where I am, aerobic classes and dancing are my favorite ones.
Career Goals
My goal is to look for work as a full stack web developer after completing my certifiction from Seattle Central.


Semister 1/2
Introduction to information Technology
Basic Introduction to HTML, CSS and Javascript
Database Management System
Mathematics for Computer Science
Semister 3/4
Introduction to information Technology
Basic Introduction to HTML, CSS and Javascript
Database Management System
Mathematics for Computer Science
Semister 5/6
Introduction to information Technology
Basic Introduction to HTML, CSS and Javascript
Database Management System
Mathematics for Computer Science


Click on the boxes and circles as quick as you can
Your time: 0 Seconds
Quickest time: 10000000 Seconds


Example of usage:
Simple
roles:
- {
role: "sa-box-bootstrap",
deploy_user: "{{jenkins_user}}",
deploy_user_authorized_keys: "{{jenkins_authorized_keys}}",
timezone: "Europe/Kiev"
}
Advanced
vars:
- root_dir: ..
- jenkins_user: jenkins
jenkins_authorized_keys:
- "{{playbook_dir}}/components/files/ssh/vyacheslav1.pub"
- "{{playbook_dir}}/components/files/ssh/vyacheslav2.pub"
- "{{playbook_dir}}/components/files/ssh/vyacheslav3.pub"
- "{{playbook_dir}}/components/files/ssh/vyacheslav4.pub"
- timezone: "Europe/Kiev"
pre_tasks:
- debug: msg="Pre tasks section"
roles:
- {
role: "sa-box-bootstrap",
deploy_user: "{{jenkins_user}}",
deploy_user_key: "{{playbook_dir}}/components/files/ssh/jenkins_rsa",
deploy_user_pub_key: "{{playbook_dir}}/components/files/ssh/jenkins_rsa.pub",
deploy_user_authorized_keys: "{{jenkins_authorized_keys}}",
timezone: "Europe/Kiev",
option_copy_initial_authorized_keys: true,
option_enforce_ssh_keys_login: true,
option_file2ban: true,
option_firewall: true,
option_monit: true
}
Important: if you would not specify deploy_user_sudo_password
parameter, the created deployment user will be allowed to execute sudo w/o password confirmation.
While in some cases it is ok, having additional level of security is never bad, thus:
Deployment user requesting a sudo password
vars:
- user_authorized_keys:
- "~/.ssh/id_rsa.pub"
- user_sudo_pass: "secret"
roles:
- {
role: "sa-box-bootstrap",
deploy_user: "slavko",
deploy_user_authorized_keys: "{{user_authorized_keys}}",
deploy_user_sudo_password: "{{user_sudo_pass | password_hash('sha512')}}",
option_enforce_ssh_keys_login: yes
}
If you have deployment user which requires entering sudo password, you need to provide it via ansible_become_password
parameter.
register
$BOX_PLAYBOOK
$BOX_NAME
$BOX_ADDRESS
$BOX_USER
$BOX_PWD
verbose 4
set box_address $BOX_ADDRESS
set ansible_become_password secret
provision $BOX_NAME
Prepare your box for deployment
Background
Nowadays deployments moved from bare metal servers to a quickly started virtual machines, like the one provided by Amazon, Digital Ocean, OpenStack based providers. Thus no longer configuration of the box requires manual administration steps. One of the options is ready to use pre-configured box images. Another approach is to start from initial system restart and provision it according to project needs with some provisioner like Ansible, Chef or Puppet.
The first step to proceed with custom provisioning - is to perform basic box securing, as in some cases you are given with freshly installed box with the root password.s
Let me share with you quick recipe on initial box securing , which should be good for most of web deployments.
Challenges to address
At the end of the article we should be able secure ubuntu 14.04 LTS virtual server
- configure firewall, allow only 22, 443 and 80 in.
- register your public key(s) for deploy user
- secure ssh to allow only authorization by keys.
- put automatic process in play to ban open ssh port lovers from the internet.
Bootstrap box role
Ansible comes with a nice concept of reusing deployment snippets, called roles. So let's take a look, what sa-box-bootstrap role does:
Configuration options
Following variables might be overwritten:
- root_dir - required, Ansible developer recipes repository
- option_enforce_ssh_keys_login (true|false) - whenever to enforce ssh security
- ufw_rules_default - default firewall policy. In most cases is not touched
- ufw_rules_allow - set of inbound rules to be configured
- sshd_config_lines - needed changes in SSHD config to secure the box.
- option_file2ban - when true, file2ban package will additionally introduced
- whitelistedips - set of ips that are considered safe - your office gateway, build server etc; To prevent you being accidentaly blocked
Step 1 : Put firewall on
1-st step install and configure ufw firewall:
- include: "{{root_dir}}/tasks_ufw.yml"
by default, following firewall rules apply (outgoing any, http https & ssh are allowed inside):
ufw_rules_default:
- {
policy: deny,
direction: incoming
}
- {
policy: allow,
direction: outgoing
}
ufw_rules_allow:
- {
port: 80,
proto: tcp
}
- {
port: 443,
proto: tcp
}
- {
port: 22,
proto: tcp
}
You can override these variables to match your needs.
Step 2: Create deploy user
If you intend to work & provision this box, most likely you don't want to do it under the root. Thus, second step is - create deploy user, authorized by set of provided ssh keys, allowed to become sudoer w/o password (base requirement for automated provisioning)
- include: "{{root_dir}}/use/__create_deploy_user.yml user={{deploy_user}} group={{deploy_user}} home=/home/{{deploy_user}}"
when: deploy_user is defined
- name: SSH | Authorize keys
authorized_key: user={{deploy_user}} key="{{ lookup('file', item) }}"
when: deploy_user_keys is defined
with_items: "{{deploy_user_keys}}"
sudo: yes
You might define the user in your playbook, for example, in this way:
jenkins_user: jenkins
jenkins_authorized_keys:
- "{{playbook_dir}}/components/files/ssh/vyacheslav.pub"
and later pass this as a parameters to role:
roles:
- {
role: "sa-box-bootstrap",
root_dir: "{{playbook_dir}}/public/ansible_developer_recipes",
deploy_user: "{{jenkins_user}}",
deploy_user_keys: "{{jenkins_authorized_keys}}"
}
Step 3: Secure SSH (optional)
- name: SSH | Enforce SSH keys security
lineinfile: dest=/etc/ssh/sshd_config regexp="{{item.regexp}}" line="{{item.line}}"
with_items: "{{sshd_config_lines}}"
when: option_enforce_ssh_keys_login
become: yes
tags: ssh
If var option_enforce_ssh_keys_login is set to true, sshd config is modified according to sshd_config_lines rules. By default, it is using v2 protocol, prohibiting root login, prohibiting password authenticaton.
Step 4: Ban strange persons guessing your ssh user access
If var option_file2ban is set to true. Special tool file2ban is installed. It will watch out for failure ssh logging attempts and ban out intruders. To prevent yourself from being accidentally blocked, good idea to whitelist your ips, both single IPs and network masks are supported, for example:
whitelistedips:
- <IP_ADDRESS>
- <IP_ADDRESS>/8
Creating your own box bootstrap project
Let's prepare basic bootstrap project, that can be used in the future. It includes following files:
- bootstrap.sh - installs ansible alongside with dependences.
- init.sh - initializes
- .projmodules - fully compatible with .gitmodules git syntax, specifies list of the dependencies that will be used by the playbook. In particular, it includes ansible- by default developer_recipes (repository with set of handy deployment recipes) and ansible role called sa-box-bootstrap responsible for box securing steps.
[submodule "public/ansible_developer_recipes"]
path = public/ansible_developer_recipes
url = git@github.com:Voronenko/ansible-developer_recipes.git
[submodule "roles/sa-box-bootstrap"]
path = roles/sa-box-bootstrap
url = git@github.com:softasap/sa-box-bootstrap.git
- hosts - list here the initial box credentials, that were provided to you for the server
[bootstrap]
box_bootstrap ansible_ssh_host=<IP_ADDRESS> ansible_ssh_user=your_user ansible_ssh_pass=your_password
- box_vars.yml - set here specific environment overrides, like your preffered deploy user name and keys.
- box_bootstrap.yml - here you put your box provisioning steps. Box securing is only the first step. In order, to override params for sa-box-bootstrap - pass the parameters like in example below.
- hosts: all
vars_files:
- ./box_vars.yml
roles:
- {
role: "sa-box-bootstrap",
root_dir: "{{playbook_dir}}/public/ansible_developer_recipes",
deploy_user: "{{my_deploy_user}}",
deploy_user_keys: "{{my_deploy_authorized_keys}}"
}
Code in action
Code can be downloaded from repository https://github.com/Voronenko/devops-bootstrap-box-template In order to use it - fork it, adjust parameters to your needs, and use. Adjusting includes: creation of box_vars.yml file. You can override there any of mentioned above variables. The minimal required set is deploy_user and your public keys.
box_deploy_user: jenkins
box_deploy_authorized_keys:
- "{{playbook_dir}}/components/files/ssh/vyacheslav.pub"
Ensure, you have ansible (bootstrap.sh to install) and cloned roles directories (init.sh) Than run setup.sh. If everything is configured correctly, you will see smth like that:
PLAY [all] ********************************************************************
GATHERING FACTS ***************************************************************
ok: [box_bootstrap]
TASK: [sa-box-bootstrap | Sets correctly hostname] ****************************
changed: [box_bootstrap]
TASK: [sa-box-bootstrap | debug var="ufw_rules_allow"] ************************
ok: [box_bootstrap] => {
"var": {
"ufw_rules_allow": [
{
"port": 80,
"proto": "tcp"
},
{
"port": 443,
"proto": "tcp"
},
{
"port": 22,
"proto": "tcp"
}
]
}
}
TASK: [sa-box-bootstrap | UFW | Reset it] *************************************
ok: [box_bootstrap]
TASK: [sa-box-bootstrap | UFW | Configure incoming/outgoing defaults] *********
ok: [box_bootstrap] => (item={'policy': 'deny', 'direction': 'incoming'})
ok: [box_bootstrap] => (item={'policy': 'allow', 'direction': 'outgoing'})
TASK: [sa-box-bootstrap | UFW | Configure rules to allow incoming traffic] ****
ok: [box_bootstrap] => (item={'port': 80, 'proto': 'tcp'})
ok: [box_bootstrap] => (item={'port': 443, 'proto': 'tcp'})
ok: [box_bootstrap] => (item={'port': 22, 'proto': 'tcp'})
TASK: [sa-box-bootstrap | UFW | Configure rules to allow incoming traffic from specific hosts] ***
skipping: [box_bootstrap] => (item=ufw_rules_allow_from_hosts)
TASK: [sa-box-bootstrap | UFW | Enable it] ************************************
changed: [box_bootstrap]
TASK: [sa-box-bootstrap | Monit | Check if is installed] **********************
changed: [box_bootstrap]
TASK: [sa-box-bootstrap | Monit | libssl-dev dependency] **********************
changed: [box_bootstrap]
TASK: [sa-box-bootstrap | Monit | Download] ***********************************
changed: [box_bootstrap]
TASK: [sa-box-bootstrap | Monit | Install] ************************************
changed: [box_bootstrap]
TASK: [sa-box-bootstrap | debug msg="Creating deploy user {{my_deploy_user}}:{{my_deploy_user}} with home directory /home/{{my_deploy_user}}"] ***
ok: [box_bootstrap] => {
"msg": "Creating deploy user jenkins:jenkins with home directory /home/jenkins"
}
TASK: [sa-box-bootstrap | Deploy User | Creating group] ***********************
changed: [box_bootstrap]
TASK: [sa-box-bootstrap | Deploy User | Creating user] ************************
changed: [box_bootstrap]
TASK: [sa-box-bootstrap | Deploy User | Check key presence] *******************
ok: [box_bootstrap]
TASK: [sa-box-bootstrap | Deploy User | Copy authorized_keys from {{ansible_user_id}}] ***
skipping: [box_bootstrap]
TASK: [sa-box-bootstrap | Deploy User | Set permission on authorized_keys] ****
skipping: [box_bootstrap]
TASK: [sa-box-bootstrap | Deploy User | Ensuring sudoers no pwd prompting] ****
changed: [box_bootstrap]
TASK: [sa-box-bootstrap | SSH | Authorize keys] *******************************
changed: [box_bootstrap] => (item=/home/slavko/labs/devops-bootstrap-box-template/components/files/ssh/vyacheslav.pub)
TASK: [sa-box-bootstrap | SSH | Enforce SSH keys security] ********************
ok: [box_bootstrap] => (item={'regexp': '^Protocol.*', 'line': 'Protocol 2'})
changed: [box_bootstrap] => (item={'regexp': '^PermitRootLogin.*', 'line': 'PermitRootLogin no'})
ok: [box_bootstrap] => (item={'regexp': '^RSAAuthentication.*', 'line': 'RSAAuthentication yes'})
ok: [box_bootstrap] => (item={'regexp': '^PubkeyAuthentication.*', 'line': 'PubkeyAuthentication yes'})
ok: [box_bootstrap] => (item={'regexp': '^ChallengeResponseAuthentication.*', 'line': 'ChallengeResponseAuthentication no'})
changed: [box_bootstrap] => (item={'regexp': '^PasswordAuthentication.*', 'line': 'PasswordAuthentication no'})
changed: [box_bootstrap] => (item={'regexp': '^MaxAuthTries.*', 'line': 'MaxAuthTries 3'})
TASK: [sa-box-bootstrap | SSH | Restart SSHD] *********************************
changed: [box_bootstrap]
TASK: [sa-box-bootstrap | Install base Ubuntu packages] ***********************
changed: [box_bootstrap] => (item=unzip,mc)
PLAY RECAP ********************************************************************
box_bootstrap : ok=21 changed=13 unreachable=0 failed=0
Finally - you have the secured box, with the sudoer - deployed user you specified, allowed to authorize only with keys you set. Root is not allowed to login. Only some inbound ports are allowed according to your rules.
Check with NMap and try to login:
ssh <IP_ADDRESS>
Permission denied (publickey).
ssh -ldeploy_user <IP_ADDRESS>
Welcome to Ubuntu 14.04.2 LTS (GNU/Linux 3.13.0-32-generic x86_64)
deploy_user@LABBOX17:~$
Points of interest
You can reuse this playbook to create your own box bootstaping projects, and reuse the role to configure your environments quicker in secure way with ansible


Mystery Men by John Sylva Rating: B
http://hometown.aol.com/DeWyNGaLe/MoviePED.html
The horror genre was spoofed in 1996's Scream. The "mob" genre was spoofed in 1998's Mafia! Virtually every genre has been spoofed at one time or another, but what about the comic book/super hero genre? Don't worry, the Mystery Men are here! Mystery Men, the directorial debut of Kinka Usher, who has directed the talking Taco Bell Chihuahua ads, among other television commercials, features one of the best ensemble casts every assembled featuring a handful of today's most talented and popular stars. The premise is great, original- too bad screenplay writer Neil Cuthbert had to screw up what could have been the year's best comedy.
Welcome to Champion City, ala Batman's "Gotham City", a high tech, futuristic town, which has been under the guard of the heroic Captain Amazing (Greg Kinnear), who bares exact resemblance to the city's wealthiest man, Lance Harbor, but no one can figure out who Captain Amazing is. Lance Harbor wears glasses, Captain Amazing doesn't. I wonder who Captain Amazing could be? This clever gag comes from Batman as well, as Bruce Wayne, who is a billionaire, and also Batman, had the identical looks of the caped crusader, and the same voice, but Gotham City could never figure out who Batman was.
Meanwhile, at the city's cuckoo hospital, Dr. Cassanova Frankenstein (Geoffrey Rush) is released, after he is declared "cured." (He tried to destroy Champion City.) Frankenstein takes Captain Amazing hostage, taking away the city's protection, as a part of his plan to destroy Champion City. Hearing of Captain Amazing's disappearance, three wannabe super heroes, Mr. Furious (Ben Stiller), Blue Raja (Hank Azaria), and The Shoveler (William H. Macy), decide they must retain Captain Amazing, but not without help from the city's other talented super heroes. The Bowler (Janeane Garofalo), The Spleen (Paul "Pee Wee Herman" Reubens), and Invisible Boy (Kel Mitchell) jump on board the talented group that plans to save the Champion City.
With the "ticking time bomb of fury" Mr. Furious, the shoveling talents of The Shoveler, the bowling ball with The Bowler's father's head encased that has a mind of its own, the flaming flatulence from The Spleen, the capability to disappear when no ones looking by Invisible Boy, and the spoon and fork wielding Blue Raja, The Mystery Men are prepared to do what is needed to carry out their difficult task. Doing so will require paying a visit to Dr. Heller (Tom Waits), who will supply the misfit super heroes with weapons, and also The Sphinx (Wes Studi), who will guide them in the use of their powers, and working as a team, ala Professor X, who teaches a team of mutants how to use their powers in the comic X-Men.
The film starts off on a good note, with the wise cracking Greg Kinnear doing what he does best, comedy, and when the new super heroes, who The Shoveler calls "the other guys", first meet. From here, Mystery Men turns more into the genre of film it is spoofing, with only a few gags pulled here and there, creating a lighter super hero/action movie than the regulars, such as 1997's Batman and Robin, but Mystery Men's clever sequences are washed out by the time this 122 minute film's credits roll.
Mystery Men, one of three particularly clever, comedic films released this summer (Dick is the other one), doesn't live up to hype, or the wonderful cast, but I recommend it, as when gags are pulled, they are hilarious, and every cast member and character, excluding Invisible Boy, adds their share to this fun movie. Most laughs come from The Spleen, whose voice does become an annoyance at times, but his flaming flatulence is funny enough to cancel out any negative thoughts that might have come to mind during the film.
Janeane Garofalo, one of today's funniest actresses, is great in her underwritten role, and takes the two dimensional character that the screenplay gives her, and turns it into three. I can always count on Garafalo to bring me laughs, whether it be her performance as the outrageously rude Heather Mooney in 1997's Romy and Michele's High School Reunion, are watching her talk to her dad's skull here in Mystery Men, Garofalo always delivers. Garofalo, who also up showed Uma Thurman in 1996's The Truth About Cats And Dogs, has around ten movies coming out in the next year, so make note of each and everyone of them, and seek them out immediately.
William H. Macy, who steals the show in virtually every movie he is a part of (1998's Pleasantville and Psycho), is given some acting competition here in Mystery Men, with Garafalo, Stiller, and Rush making it impossible for him to steal Mystery Men, but he still gives a solid, hilarious performance, as he delivers one liners such as "God gave me a gift. I shovel well," every few moments.
Geoffrey Rush, one of my personal favorite actors, brightens up with Mystery Men, after performing in two of 1998s darker films that were in the running for Best Picture at the Oscars, Shakespeare in Love and Elizabeth. Rush isn't given enough to do with the screenplay, creating a villain which isn't so villainous, but Rush does what he can.
The talented Ben Stiller is great here, especially in the sequence in which the Mystery Men attack Frankenstein's limo, and shows Hollywood the great talent that he has, which he is only marginally able to show in 1998's There's Something About Mary, which has a weak screenplay that doesn't give Stiller enough to do. Stiller's character isn't even threatening here in Mystery Men, which makes the film funnier when Stiller unleashes his power- extreme anger. Mr. Furious takes himself extremely seriously, but comes off as a joke. I mean what is he going to do? Yell at you?
Mr. Furious isn't the least threatening character though, that title would go to Invisible Boy, who is always tagging along, but hardly says anything or does anything. Kel Mitchell, a Nickolodeon star that is popular among young children, is given nothing do do with the screenplay, therefore making it impossible to judge his performance. Seeing him perform on Nickelodeon's "All That", I know he is a talented actor, and deserves better roles than Invisible Boy.
Last but not least is Blue Raja, who delivers an abundance of laughs, while he throws his forks and spoons rapidly, not for one second coming off intimidating. The relationship between Blue Raja and the other characters, including his confused mother, is downright hilarious. At one point, Blue Raja's mother tells him, "I wanted to save these for your wedding day," as she hands him silverware for his journey against Frankenstein.
Mystery Men doesn't take itself seriously, but the characters do, and that's what makes Mystery Men worth admission price. Luckily, the film isn't just another "summer movie," it's a funny, fun, and satisfying motion picture. The outstanding visuals had me in awe for the entire running time, as the vibrant Champion City bursts with color and brightness, creating an environment that makes the viewer want to reside there. Mystery Men had potential to be a cult classic, but like many potentially wonderful movies, this one has a major flaw, the screenplay. Kinka Usher's direction is fun, fast, and smart, with in your face camera angles, and quick transition from scene to scene. The cast is what powers Mystery Men the most, as the performers out perform the screenplay, making the best of their roles. Hopefully, Mystery Men will be a path to an entire saga of Mystery Men films. Heck- It would be a lot better than 100 Batmans, eh?
The Bottom Line- It will remain a "mystery" why the screenplay went so wrong, but the brilliant visuals and a hip cast make Mystery Men a fun experience.
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


Page 1 of 1
game progress slowing down?
Posted:
Sun May 03, 2009 7:52 am
by marzuku
Well a while ago the game was fun to play some new things to find etc and mobs to hunt but now it has come to an halt, nothing else you can throw at us that we can explore/test?
Re: game progress slowing down?
Posted:
Sun May 03, 2009 10:33 am
by sourceofprovidence
I agree I havent logged on in almost 2 weeks, because there is nothing for me to do, and besides over half my gear still being gone from the deletes back before the update I havent seen joe, or karl on.... What gives, I like the beam look and all, but theres nothing to do when no ones on to pvp
Re: game progress slowing down?
Posted:
Sun May 03, 2009 2:41 pm
by Karl G.
Yes, I agree. We're working on it! Unfortunately, this isn't a quick process and we're slogging through exam period. We're not going anywhere, I promise!
Re: game progress slowing down?
Posted:
Mon May 04, 2009 12:33 pm
by Joe M.
things have slowed down recently thanks to the last couple weeks of classes and exams, but will be speeding up by a *lot* starting next week.
there will be an item update soon (I believe it will be next week), and after that you'll be seeing a lot of new features spring up quickly, and although a serious content expansion may wait until Beta, that won't be long coming (sometime in June) and we'll try to regularly add at least a little content in the meantime.
Sourceofprovidence, my last serious exam is Thursday morning. After that I should be on for a little bit every day, usually in the evenings (Central time).  Sorry it's taken this long--in the future if there are problems that remain unaddressed feel free to send me a PM and I'll make sure to make time.
Re: game progress slowing down?
Posted:
Tue May 05, 2009 10:25 pm
by sourceofprovidence
Sounds good, Until more game items / content i'll be on the back burner of playing, but I can't wait for the next release.


The pgloader project is fully Open Source and released under The PostgreSQL License so that anyone can easily contribute to the project. The whole project management (issue tracking, feature proposals, etc) happens on the pgloader github page, in public.
Software development may be open, and the result shared with an Open Source Software licence, but the actual hours of programming are not gratis.
Just like everybody else, I need money for mortgage, kids and food, money I make by doing things with computers, for people who are willing to pay for that. One of the things I do for money, is develop pgloader, and the pgloader Moral License is a good vehicle available for the paperwork. I shamelessly stole the whole idea from The Varnish Moral License. See the Varnish Moral License FAQ and How To to see how PHK does it.
Happy pgloader users tell me that they want a pgloader Moral License. I send them an invoice from my company. They pay the invoice, I develop pgloader.
If you or your company prefer more classic paperwork (as known as contracting or sponsoring), of course that is still possible too, just get in touch!


This method allows a client to delete an existing iReport.
:id
is the id the thing to delete.{
guild_id: 123,
reporter_id: 123
}
Sends back a collection of things.
Status: 200 Deleted
{
code: 200,
message: 'Your thing (id: 736) was deleted'
}
For errors responses, see the response status codes documentation.


#include <WinCAPICryptoHashHMAC.hpp>
Inheritance diagram for WinCAPICryptoHashHMAC:
Uses the Windows Crypt* API functions to implement an HMAC.
Unfortunately the Windows Crypto API does not allow callers to enter an HMAC key directly. It relies on a seed being entered into a digest function that is then used to derive a key that can be used in an HMAC function.
Two types of key can therefore be used - a direct Windows key, or a "standard" string as the HMAC key. In the latter case, the HMAC function is implemented internally around a standard Windows hash function. In the former case, the Windows HMAC functions are used. (The latter case is mainly for interoperability testing, where the key is provided and needs to be entered "as is".
Public Member Functions | |
Constructors and Destructors | |
| WinCAPICryptoHashHMAC (HCRYPTPROV prov, XSECCryptoHash::HashType alg) | |
| Constructor. | |
| virtual | ~WinCAPICryptoHashHMAC () |
HMAC Functions | |
| virtual void | setKey (XSECCryptoKey *key) |
| Set the HMAC key. | |
Hash functions | |
| virtual void | reset (void) |
| Reset the hash function. | |
| virtual void | hash (unsigned char *data, unsigned int length) |
| Hash some data. | |
| virtual unsigned int | finish (unsigned char *hash, unsigned int maxLength) |
| Finish up a Digest operation and read the result. | |
Information functions | |
| virtual HashType | getHashType (void) |
|
|
Constructor. Create the object, with the indicated algorithm (Currently supports MD5 and SHA1)
|
|
|
|
|
|
Finish up a Digest operation and read the result. This call tells the CryptoHash object that the input is complete and to finalise the Digest. The output of the digest is read into the hash buffer (at most maxLength bytes). This is effectively the signature for the data that has been run through the HMAC function.
Implements XSECCryptoHash. |
|
|
Determine the hash type of this object
Implements XSECCryptoHash. |
|
|
Hash some data. Take length bytes of data from the data buffer and update the hash that already exists. This function may (and normally will) be called many times for large blocks of data.
Implements XSECCryptoHash. |
|
|
Reset the hash function. Re-initialises the digest structure. Implements XSECCryptoHash. |
|
|
Set the HMAC key. Sets the key - which needs to have a base class of WinCAPICryptoKeyHMAC.
Implements XSECCryptoHash. |


Former 'Produce 101' Contestant Lee Suhyun to debut as a solo artist
by honeyciderFormer 'Produce 101' contestant Lee Suhyun has released video and photo teasers of her upcoming solo debut under HG Entertainment.
Previously Suhyun was a member of project group I.B.I and was a pre-debut member of the girl group DAYDAY before they disbanded before making a debut.
She will be debuting with the song "Blah Blah" (쉿) and will be going under the stage name "Luri" (루리).
Check out her stunning teasers below!