We can’t guess about which functions are fast and which are slow - we need actual measurements when we’re curious. That’s where benchmarking comes in. In this lesson, we’ll learn about how easy it is to measure the speed of our code.
Table of Contents
About Benchee
While there is a function in Erlang that can be used for basic measurements of a function’s execution time, it’s not as nice to use as some of the available tools and it doesn’t give you multiple measurements to get useful statistics from, so we’re going to use Benchee. Benchee provides us with a range of statistics with easy comparisons between scenarios, a great feature that allows us to test different inputs to the functions we’re benchmarking, and several different formatters that we can use to display our results, as well as the ability to write your formatter if desired.
Usage
To add Benchee to your project, add it as a dependency to your mix.exs
file:
defp deps do
[{:benchee, "~> 1.0", only: :dev}]
end
Then we call:
$ mix deps.get
...
$ mix compile
The first command downloads and installs Benchee. You may be asked to install Hex along with it. The second compiles the Benchee application. Now we’re ready to write our first benchmark.
An important note before we begin: When benchmarking, it is important to not use iex
since that behaves differently and is often much slower than how your code is most likely being used in production.
So, let’s create a file that we’re calling benchmark.exs
, and in that file we’ll add the following code:
list = Enum.to_list(1..10_000)
map_fun = fn i -> [i, i * i] end
Benchee.run(%{
"flat_map" => fn -> Enum.flat_map(list, map_fun) end,
"map.flatten" => fn -> list |> Enum.map(map_fun) |> List.flatten() end
})
Now to run our benchmark, we call:
$ mix run benchmark.exs
And we should see something like the following output in your console:
Operating System: Linux
CPU Information: Intel(R) Core(TM) i7-4790 CPU @ 3.60GHz
Number of Available Cores: 8
Available memory: 15.61 GB
Elixir 1.8.1
Erlang 21.3.2
Benchmark suite executing with the following configuration:
warmup: 2 s
time: 5 s
memory time: 0 ns
parallel: 1
inputs: none specified
Estimated total run time: 14 s
Benchmarking flat_map...
Benchmarking map.flatten...
Name ips average deviation median 99th %
flat_map 2.40 K 416.00 μs ±12.88% 405.67 μs 718.61 μs
map.flatten 1.24 K 806.20 μs ±20.65% 752.52 μs 1186.28 μs
Comparison:
flat_map 2.40 K
map.flatten 1.24 K - 1.94x slower +390.20 μs
Of course, your system information and results may be different depending on the specifications of the machine you are running your benchmarks on, but this general information should all be there.
At first glance, the Comparison
section shows us that our map.flatten
version is 1.94x slower than flat_map
. It also shows that on average it is about 390 microseconds slower which puts things into perspective. All helpful to know! However, let’s look at the other statistics that we get:
- ips - this stands for “iterations per second,” which tells us how often the given function can be executed in one second. For this metric, a higher number is better.
- average - this is the average execution time of the given function. For this metric, a lower number is better.
- deviation - this is the standard deviation, which tells us how much the results for each iteration varies in the results. Here it is given as a percentage of the average.
- median - when all measured times are sorted, this is the middle value (or average of the two middle values when the number of samples is even).
Because of environmental inconsistencies this is more stable than the
average
, and somewhat more likely to reflect the normal performance of your code in production. For this metric, a lower number is better. - 99th % - 99% percent of all measurements are faster than this, which makes this sort of worst case performance. Lower is better.
There are also other available statistics, but these five are frequently the most helpful and commonly used for benchmarking, which is why they are displayed in the default formatter. To learn more about the other available metrics, check out the documentation on hexdocs.
Configuration
One of the best parts of Benchee is all the available configuration options. We’ll go over the basics first since they don’t require code examples, and then we’ll show how to use one of the best features of Benchee - inputs.
Basics
Benchee takes a wealth of configuration options.
In the most common Benchee.run/2
interface, these are passed as the second argument in the form of an optional keyword list:
Benchee.run(%{"example function" => fn -> "hi!" end},
warmup: 4,
time: 10,
inputs: nil,
parallel: 1,
formatters: [Benchee.Formatters.Console],
print: [
benchmarking: true,
configuration: true,
fast_warning: true
],
console: [
comparison: true,
unit_scaling: :best
]
)
The available options are the following (also documented in hexdocs).
- warmup - the time in seconds for which a benchmarking scenario should be run without measuring times before real measurements start. This parameter simulates a “warm” running system. Defaults to 2.
- time - the time in seconds for how long each benchmarking scenario should be run and measured. Defaults to 5.
- memory_time - the time in seconds for how long memory consumption should be measured for every benchmarking scenario. We’ll look at that later. Defaults to 0.
- inputs - a map with strings representing the input name as the keys and the actual input as the values. Can also be a list of tuples in the form
{input_name, actual_value}
Defaults tonil
(no inputs). We’ll cover this in detail in the next section. - parallel - the number of processes to use to benchmark your functions.
So, if you set
parallel: 4
, then 4 processes are spawned that all execute the same function for the giventime
. When these finish, then 4 new processes are spawned for the next function. This gives you more data in the same time, but also puts a load on the system interfering with benchmark results. This can be useful to simulate a system under load which is sometimes helpful, but should be used with some caution as this can affect results in unpredictable ways. Defaults to 1 (which means no parallel execution). - formatters - a list of formatters either as a module implementing the formatter behaviour, a tuple of said module and options it should take or formatter functions. They are run when using
Benchee.run/2
. Functions need to accept one argument (which is the benchmarking suite with all data) and then use that to produce output. Defaults to the builtin console formatterBenchee.Formatters.Console
. We’ll cover this more in a later section. - measure_function_call_overhead - Measure how long an empty function call takes and deduct this from each measured run time. Helps with the accuracy of very fast benchmarks. Defaults to true.
- pre_check - whether or not to run each job with each input - including all given before or after scenario or each hooks - before the benchmarks are measured to ensure that your code executes without error. This can save time while developing your suites. Defaults to
false
. - save - specify a
path
where to store the results of the current benchmarking suite, tagged with the specifiedtag
. See Saving & Loading in the Benchee docs. - load - load a saved suite or suites to compare your current benchmarks against. Can be a string or a list of strings or patterns. See Saving & Loading in the Benchee docs.
- print - a map or keyword list with the following options as atoms for the keys and values of either
true
orfalse
. This lets us control if the output identified by the atom is printed during the standard benchmarking process. All options are enabled by default (true). Options are:- benchmarking - print when Benchee starts benchmarking a new job.
- configuration - a summary of configured benchmarking options including estimated total run time is printed before benchmarking starts.
- fast_warning - warnings are displayed if functions are executed too fast, potentially leading to inaccurate measures.
- unit_scaling - the strategy for choosing a unit for durations and counts.
When scaling a value, Benchee finds the “best fit” unit (the largest unit for which the result is at least 1).
For example,
1_200_000
scales to 1.2 M, while800_000
scales to 800 K. The unit scaling strategy determines how Benchee chooses the best fit unit for an entire list of values, when the individual values in the list may have different best fit units. There are four strategies, all given as atoms, defaulting to:best
:- best - the most frequent best fit unit is used. A tie results in the larger unit being selected.
- largest - the largest best fit unit is used
- smallest - the smallest best fit unit is used
- none - no unit scaling occurs. Durations is displayed in nanoseconds, and ips counts is displayed without units.
:before_scenario
/after_scenario
/before_each
/after_each
- we won’t get into those too much here but if you need to do something before/after your benchmarking function without it being measured refer to Benchee’s hooks section
Inputs
It’s important to benchmark your functions with data that reflects what that function might actually operate on in the real world.
Frequently a function can behave differently on small sets of data versus large sets of data! This is where Benchee’s inputs
configuration option comes in.
This allows you to test the same function but with as many different inputs as you like, and then you can see the results of the benchmark with each of those functions.
So, let’s look at our original example again:
list = Enum.to_list(1..10_000)
map_fun = fn i -> [i, i * i] end
Benchee.run(%{
"flat_map" => fn -> Enum.flat_map(list, map_fun) end,
"map.flatten" => fn -> list |> Enum.map(map_fun) |> List.flatten() end
})
In that example we’re only using a single list of the integers from 1 to 10,000. Let’s update that to use a couple different inputs so we can see what happens with smaller and larger lists. So, open that file, and we’re going to change it to look like this:
map_fun = fn i -> [i, i * i] end
inputs = %{
"small list" => Enum.to_list(1..100),
"medium list" => Enum.to_list(1..10_000),
"large list" => Enum.to_list(1..1_000_000)
}
Benchee.run(
%{
"flat_map" => fn list -> Enum.flat_map(list, map_fun) end,
"map.flatten" => fn list -> list |> Enum.map(map_fun) |> List.flatten() end
},
inputs: inputs
)
You’ll notice two differences.
First, we now have an inputs
map that contains the information for our inputs to our functions.
We’re passing that inputs map as a configuration option to Benchee.run/2
.
And since our functions need to take an argument now, we need to update our benchmark functions to accept an argument, so instead of:
fn -> Enum.flat_map(list, map_fun) end
we now have:
fn list -> Enum.flat_map(list, map_fun) end
Let’s run this again using:
$ mix run benchmark.exs
Now you should see output in your console like this:
Operating System: Linux
CPU Information: Intel(R) Core(TM) i7-4790 CPU @ 3.60GHz
Number of Available Cores: 8
Available memory: 15.61 GB
Elixir 1.8.1
Erlang 21.3.2
Benchmark suite executing with the following configuration:
warmup: 2 s
time: 5 s
memory time: 0 ns
parallel: 1
inputs: large list, medium list, small list
Estimated total run time: 42 s
Benchmarking flat_map with input large list...
Benchmarking flat_map with input medium list...
Benchmarking flat_map with input small list...
Benchmarking map.flatten with input large list...
Benchmarking map.flatten with input medium list...
Benchmarking map.flatten with input small list...
##### With input large list #####
Name ips average deviation median 99th %
flat_map 13.20 75.78 ms ±25.15% 71.89 ms 113.61 ms
map.flatten 10.48 95.44 ms ±19.26% 96.79 ms 134.43 ms
Comparison:
flat_map 13.20
map.flatten 10.48 - 1.26x slower +19.67 ms
##### With input medium list #####
Name ips average deviation median 99th %
flat_map 2.66 K 376.04 μs ±23.72% 347.29 μs 678.17 μs
map.flatten 1.75 K 573.01 μs ±27.12% 512.48 μs 1076.27 μs
Comparison:
flat_map 2.66 K
map.flatten 1.75 K - 1.52x slower +196.98 μs
##### With input small list #####
Name ips average deviation median 99th %
flat_map 266.52 K 3.75 μs ±254.26% 3.47 μs 7.29 μs
map.flatten 178.18 K 5.61 μs ±196.80% 5.00 μs 10.87 μs
Comparison:
flat_map 266.52 K
map.flatten 178.18 K - 1.50x slower +1.86 μs
We can now see information for our benchmarks, grouped by input. This simple example doesn’t provide any mind blowing insights, but you’d be surprised how much performance varies based on input size!
Formatters
The console output that we’ve seen is a helpful beginning for measuring the runtimes of your functions, but it’s not your only option! In this section we’ll look briefly at the three other available formatters, and also touch on what you’d need to do to write your formatter if you like.
Other formatters
Benchee has a console formatter built in, which is what we’ve seen already, but there are three other officially supported formatters -
benchee_csv
,
benchee_json
and
benchee_html
.
Each of them does exactly what you would expect, which is writing the results to the named file formats so you can work with your results further in whichever format you like.
Each of these formatters is a separate package, so to use them you need to add them as dependencies to your mix.exs
file like so:
defp deps do
[
{:benchee_csv, "~> 1.0", only: :dev},
{:benchee_json, "~> 1.0", only: :dev},
{:benchee_html, "~> 1.0", only: :dev}
]
end
While benchee_json
and benchee_csv
are simple, benchee_html
is actually very full featured!
It can help you produce nice graphs and charts from your results easily, and you can even export them as PNG images.
You check out an example html report if you’re interested, it includes graphs like this one:
All three formatters are well-documented on their respective GitHub pages, so we won’t cover the details of them here.
Custom formatters
If the four offered formatters aren’t enough for you, you can also write custom formatter.
Writing a formatter is pretty easy.
You need to write a function that accepts a %Benchee.Suite{}
struct, and from that you can pull whatever information you like.
Information about what exactly is in this struct can be found on GitHub or HexDocs.
The codebase is well-documented and easy to read if you’d like to see what sorts of information could be available for writing custom formatters.
You could also write a more full featured formatter that adopts the Benchee.Formatter behaviour
we’ll stick with the simpler function version here.
For now, we’ll show a quick example of what a custom formatter might look like below as an example of how easy it is. Let’s say we just want an extremely minimal formatter that prints the average run time for each scenario - this is what that might look like:
defmodule Custom.Formatter do
def output(suite) do
suite
|> format
|> IO.write()
suite
end
defp format(suite) do
Enum.map_join(suite.scenarios, "\n", fn scenario ->
"Average for #{scenario.job_name}: #{scenario.run_time_data.statistics.average}"
end)
end
end
And then we could run our benchmark like this:
list = Enum.to_list(1..10_000)
map_fun = fn i -> [i, i * i] end
Benchee.run(
%{
"flat_map" => fn -> Enum.flat_map(list, map_fun) end,
"map.flatten" => fn -> list |> Enum.map(map_fun) |> List.flatten() end
},
formatters: [&Custom.Formatter.output/1]
)
And when we run now with our custom formatter, we would see:
Operating System: Linux
CPU Information: Intel(R) Core(TM) i7-4790 CPU @ 3.60GHz
Number of Available Cores: 8
Available memory: 15.61 GB
Elixir 1.8.1
Erlang 21.3.2
Benchmark suite executing with the following configuration:
warmup: 2 s
time: 5 s
memory time: 0 ns
parallel: 1
inputs: none specified
Estimated total run time: 14 s
Benchmarking flat_map...
Benchmarking map.flatten...
Average for flat_map:<PHONE_NUMBER>474056
Average for map.flatten:<PHONE_NUMBER>408596
Memory
We’re almost all the way to the end, but we’ve gone all this way without showing you one of Benchee’s coolest features: memory measurements!
Benchee is able to measure memory consumption, it is limited to the process your benchmark is executed in though. It can’t currently track memory consumption in other processes (like worker pools).
Memory consumption includes all the memory your benchmarking scenario used - also the memory that was garbage collected so it does not necessarily represent the maximum process memory size.
How do you use it? Well you just use the :memory_time
option!
Operating System: Linux
CPU Information: Intel(R) Core(TM) i7-4790 CPU @ 3.60GHz
Number of Available Cores: 8
Available memory: 15.61 GB
Elixir 1.8.1
Erlang 21.3.2
Benchmark suite executing with the following configuration:
warmup: 0 ns
time: 0 ns
memory time: 1 s
parallel: 1
inputs: none specified
Estimated total run time: 2 s
Benchmarking flat_map...
Benchmarking map.flatten...
Memory usage statistics:
Name Memory usage
flat_map 624.97 KB
map.flatten 781.25 KB - 1.25x memory usage +156.28 KB
**All measurements for memory usage were the same**
As you can see, Benchee doesn’t bother displaying all the statistics as all samples taken were the same. This is actually quite common if your functions don’t include an amount of randomness. And what good would all the statistics be if they just told you the same number all the time?
Caught a mistake or want to contribute to the lesson? Edit this page on GitHub!


location.hash
location.replace()
This testcase will only work if you open it in a tab with a blank history (a new tab).


Cardigan meh letterpress tbh tote bag disrupt. Flexitarian farm-to-table polaroid, kale chips photo booth fam helvetica brunch air plant 90's yr artisan sustainable aesthetic. Actually biodiesel umami, thundercats hammock yuccie shoreditch leggings tumeric everyday carry blog yr. Affogato vexillologist fam 90's vaporware. Echo park trust fund edison bulb, pitchfork retro biodiesel
heirloom. Sustainable mixtape williamsburg, enamel pin meditation trust fund bushwick quinoa irony YOLO tattooed banjo vape distillery celiac. Cold-pressed tofu hexagon, heirloom authentic typewriter copper mug pabst pork belly PBR&B godard truffaut ramps semiotics lyft. Heirloom food truck succulents keffiyeh pitchfork. Occupy narwhal vexillologist venmo, pitchfork vape kickstarter live-edge 90's woke coloring book ramps gochujang XOXO.  Fashion axe pickled pabst coloring book.
art party brooklyn, marfa iPhone kombucha man braid cold-pressed listicle. Kombucha green juice master cleanse knausgaard, aesthetic lomo semiotics yuccie crucifix hashtag cred kogi godard disrupt. Kickstarter church-key blog jianbing, air plant yr scenester hexagon butcher. Pitchfork meditation occupy shabby chic scenester. Pinterest godard woke, fanny pack gastropub gochujang craft beer fap shabby chic banjo etsy letterpress meggings iPhone flexitarian.
Comments (152)
It's about time somebody talked about this stuff in plain English. I looked you guys up and figured you weren't Wharton School business types, but you clearly graduated from Hard Knocks U! Good on ya.
Go, gang, go! Y'all are so cute and excited about your undie company, i'm inspired.


Here, you can find instructions for your OS to hack your switch.
The source code for this site can be found here
This is isn't tested that much. Be careful!
Huge thanks to the ReSwitched team and ktemkin. Also thanks to atlas44 and ElijahZAwesome for their javascript code.
Thanks to LanderN for the bootstrap design. If you would like to see the old design go here.
Also, thank you for using my tool.
The web launcher does NOT work in Windows. There is a really noob friendly tool now called SHAIO, so we'll be using that.
Honestly, the program practically teaches itself, but I'll give instructions anyway.
1. Get the latest release of SHAIO here
2. Install it if you got the exe, or unzip the file if you got the portable zipped file.
3. Open SHAIO, then click "Payload Tool", and press ok on the popup (first use only).
4. Select "Install Drivers" in the bottom left corner. Allow the app to make changes (needs admin access), then complete the wizard.
5. Put your switch into RCM mode and plug it into your computer.
6. Click the text box at the top and select a paylod, or upload one with the "+" button, then click "Launch", and it should be done!
The Web Launcher will work on Linux, however, I suggest you do this first so we don't have errors later on:
Make a file at
/etc/udev/rules.d/50-switch.rules
With the following contents:
SUBSYSTEM=="usb", ATTR{idVendor}=="0955", MODE="0664", GROUP="plugdev"
These Operating Systems will work as is. Move on to the hacking!
You must use Chrome for this to work!
Also make sure Chrome isn't sandboxed (one user had an issue with this).
1. Put your switch in RCM mode
2. Connect your switch to your computer
3. Select your payload or upload one
4. Click "Activate"
5. Select "APX" in the prompt, then "Connect", and the payload should've been sent!
An iframe of the switchbru appstore.


Sequence diagrams
A Sequence diagram is an interaction diagram that shows how processes operate with one another and in what order.
Mermaid can render sequence diagrams. The code snippet below:
%% Example of sequence diagram
sequenceDiagram
Alice->>John: Hello John, how are you?
John-->>Alice: Great!
Renders the following diagram:
Syntax
Participants
The participants can be defined implicitly as in the first example on this page. The participants or actors are
rendered in order of appearance in the diagram source text. Sometimes you might want to show the participants in a
different order than how they appear in the first message. It is possible to specify the actor's order of
appearance by doing the following:
%% Example of sequence diagram
sequenceDiagram
participant John
participant Alice
Alice->>John: Hello John, how are you?
John-->>Alice: Great!
Renders to the diagram below:
Messages
Messages can be of two displayed either solid or with a dotted line.
[Actor][Arrow][Actor]:Message text
There are six types of arrows currently supported:
-> which will render a solid line without arrow
--> which will render a dotted line without arrow
->> which will render a solid line with arrowhead
-->> which will render a dotted line with arrowhead
-x which will render a solid line with a cross at the end (async)
--x which will render a dotted line with a cross at the end (async)
Activations
It is possible to activate and deactivate an actor. (de)activation can be dedicated declarations:
sequenceDiagram
Alice->>John: Hello John, how are you?
activate John
John-->>Alice: Great!
deactivate John
Renders to the diagram below:
There is also a shortcut notation by appending +
/-
suffix to the message arrow:
sequenceDiagram
Alice->>+John: Hello John, how are you?
John-->>-Alice: Great!
Activations can be stacked for same actor:
sequenceDiagram
Alice->>+John: Hello John, how are you?
Alice->>+John: John, can yoy hear me?
John-->>-Alice: Hi Alice, I can hear you!
John-->>-Alice: I feel great!
Stacked activations look like this:
Notes
It is possible to add notes to a sequence diagram. This is done by the notation
Note [ right of | left of | over ] [Actor]: Text in note content
See the example below:
%% Example of sequence diagram
sequenceDiagram
participant John
Note right of John: Text in note
Renders to the diagram below:
It is also possible to create notes spanning two participants:
sequenceDiagram
Alice->John: Hello John, how are you?
Note over Alice,John: A typical interaction
Loops
It is possible to express loops in a sequence diagram. This is done by the notation
loop Loop text
... statements ...
end
See the example below
%% Example of sequence diagram
sequenceDiagram
Alice->John: Hello John, how are you?
loop Reply every minute
John-->Alice: Great!
end
Alt
It is possible to express alternative paths in a sequence diagram. This is done by the notation
alt Describing text
... statements ...
else
... statements ...
end
or if there is sequence that is optional (if without else).
opt Describing text
... statements ...
end
See the example below
%% Example of sequence diagram
sequenceDiagram
Alice->>Bob: Hello Bob, how are you?
alt is sick
Bob->>Alice: Not so good :(
else is well
Bob->>Alice: Feeling fresh like a daisy
end
opt Extra response
Bob->>Alice: Thanks for asking
end
Styling
Styling of the a sequence diagram is done by defining a number of css classes. During rendering these classes are extracted from the
Classes used
| Class | Description |
|---|---|
| actor | Style for the actor box at the top of the diagram. |
| text.actor | Styles for text in the actor box at the top of the diagram. |
| actor-line | The vertical line for an actor. |
| messageLine0 | Styles for the solid message line. |
| messageLine1 | Styles for the dotted message line. |
| messageText | Defines styles for the text on the message arrows. |
| labelBox | Defines styles label to left in a loop. |
| labelText | Styles for the text in label for loops. |
| loopText | Styles for the text in the loop box. |
| loopLine | Defines styles for the lines in the loop box. |
| note | Styles for the note box. |
| noteText | Styles for the text on in the note boxes. |
Sample stylesheet
body {
background: white;
}
.actor {
stroke: #CCCCFF;
fill: #ECECFF;
}
text.actor {
fill:black;
stroke:none;
font-family: Helvetica;
}
.actor-line {
stroke:grey;
}
.messageLine0 {
stroke-width:1.5;
stroke-dasharray: "2 2";
marker-end:"url(#arrowhead)";
stroke:black;
}
.messageLine1 {
stroke-width:1.5;
stroke-dasharray: "2 2";
stroke:black;
}
#arrowhead {
fill:black;
}
.messageText {
fill:black;
stroke:none;
font-family: 'trebuchet ms', verdana, arial;
font-size:14px;
}
.labelBox {
stroke: #CCCCFF;
fill: #ECECFF;
}
.labelText {
fill:black;
stroke:none;
font-family: 'trebuchet ms', verdana, arial;
}
.loopText {
fill:black;
stroke:none;
font-family: 'trebuchet ms', verdana, arial;
}
.loopLine {
stroke-width:2;
stroke-dasharray: "2 2";
marker-end:"url(#arrowhead)";
stroke: #CCCCFF;
}
.note {
stroke: #decc93;
stroke: #CCCCFF;
fill: #fff5ad;
}
.noteText {
fill:black;
stroke:none;
font-family: 'trebuchet ms', verdana, arial;
font-size:14px;
}
Configuration
Is it possible to adjust the margins for rendering the sequence diagram.
This is done by defining mermaid.sequenceConfig or by the CLI to use a json file with the configuration. How to use
the CLI is described in the mermaidCLI page.
mermaid.sequenceConfig can be set to a JSON string with config parameters or the corresponding object.
mermaid.sequenceConfig = {
diagramMarginX:50,
diagramMarginY:10,
boxTextMargin:5,
noteMargin:10,
messageMargin:35,
mirrorActors:true
};
Possible configration params:
| Param | Descriotion | Default value |
|---|---|---|
| mirrorActor | Turns on/off the rendering of actors below the diagram as well as above it | false |
| bottomMarginAdj | Adjusts how far down the graph ended. Wide borders styles with css could generate unwantewd clipping which is why this config param exists. | 1 |


Class: Aws::EC2::Types::DescribeInstancesRequest
| Inherits: |
Struct
|
| Defined in: |
(unknown) |
Overview
Contains the parameters for DescribeInstances.
Note: When passing DescribeInstancesRequest
as input to a Client method, you can use a vanilla Hash
:
{
dry_run: false,
instance_ids: ["String"],
filters: [
{
name: "String",
values: ["String"],
},
],
next_token: "String",
max_results: 1,
}
Instance Attribute Summary collapse
-
#dry_run ⇒ Boolean
Checks whether you have the required permissions for the action, without actually making the request, and provides an error response.
-
#filters ⇒ Array<Types::Filter>
One or more filters.
-
#instance_ids ⇒ Array<String>
One or more instance IDs.
-
#max_results ⇒ Integer
The maximum number of results to return in a single call.
-
#next_token ⇒ String
The token to request the next page of results.
Instance Attribute Details
#dry_run ⇒ Boolean
Checks whether you have the required permissions for the action, without
actually making the request, and provides an error response. If you have
the required permissions, the error response is DryRunOperation
.
Otherwise, it is UnauthorizedOperation
.
#filters ⇒ Array<Types::Filter>
One or more filters.
affinity
- The affinity setting for an instance running on a Dedicated host (default
|host
).architecture
- The instance architecture (i386
|x86_64
).availability-zone
- The Availability Zone of the instance.block-device-mapping.attach-time
- The attach time for an EBS volume mapped to the instance, for example,2010-09-15T17:15:20.000Z
.block-device-mapping.delete-on-termination
- A Boolean that indicates whether the EBS volume is deleted on instance termination.block-device-mapping.device-name
- The device name for the EBS volume (for example,/dev/sdh
orxvdh
).block-device-mapping.status
- The status for the EBS volume (attaching
|attached
|detaching
|detached
).block-device-mapping.volume-id
- The volume ID of the EBS volume.client-token
- The idempotency token you provided when you launched the instance.dns-name
- The public DNS name of the instance.group-id
- The ID of the security group for the instance. EC2-Classic only.group-name
- The name of the security group for the instance. EC2-Classic only.host-Id
- The ID of the Dedicated host on which the instance is running, if applicable.hypervisor
- The hypervisor type of the instance (ovm
|xen
).iam-instance-profile.arn
- The instance profile associated with the instance. Specified as an ARN.image-id
- The ID of the image used to launch the instance.instance-id
- The ID of the instance.instance-lifecycle
- Indicates whether this is a Spot Instance or a Scheduled Instance (spot
|scheduled
).instance-state-code
- The state of the instance, as a 16-bit unsigned integer. The high byte is an opaque internal value and should be ignored. The low byte is set based on the state represented. The valid values are: 0 (pending), 16 (running), 32 (shutting-down), 48 (terminated), 64 (stopping), and 80 (stopped).instance-state-name
- The state of the instance (pending
|running
|shutting-down
|terminated
|stopping
|stopped
).instance-type
- The type of instance (for example,t2.micro
).instance.group-id
- The ID of the security group for the instance.instance.group-name
- The name of the security group for the instance.ip-address
- The public IP address of the instance.kernel-id
- The kernel ID.key-name
- The name of the key pair used when the instance was launched.launch-index
- When launching multiple instances, this is the index for the instance in the launch group (for example, 0, 1, 2, and so on).launch-time
- The time when the instance was launched.monitoring-state
- Indicates whether monitoring is enabled for the instance (disabled
|enabled
).owner-id
- The AWS account ID of the instance owner.placement-group-name
- The name of the placement group for the instance.platform
- The platform. Usewindows
if you have Windows instances; otherwise, leave blank.private-dns-name
- The private DNS name of the instance.private-ip-address
- The private IP address of the instance.product-code
- The product code associated with the AMI used to launch the instance.product-code.type
- The type of product code (devpay
|marketplace
).ramdisk-id
- The RAM disk ID.reason
- The reason for the current state of the instance (for example, shows \"User Initiated [date]\" when you stop or terminate the instance). Similar to the state-reason-code filter.requester-id
- The ID of the entity that launched the instance on your behalf (for example, AWS Management Console, Auto Scaling, and so on).reservation-id
- The ID of the instance\'s reservation. A reservation ID is created any time you launch an instance. A reservation ID has a one-to-one relationship with an instance launch request, but can be associated with more than one instance if you launch multiple instances using the same launch request. For example, if you launch one instance, you\'ll get one reservation ID. If you launch ten instances using the same launch request, you\'ll also get one reservation ID.root-device-name
- The name of the root device for the instance (for example,/dev/sda1
or/dev/xvda
).root-device-type
- The type of root device that the instance uses (ebs
|instance-store
).source-dest-check
- Indicates whether the instance performs source/destination checking. A value oftrue
means that checking is enabled, andfalse
means checking is disabled. The value must befalse
for the instance to perform network address translation (NAT) in your VPC.spot-instance-request-id
- The ID of the Spot instance request.state-reason-code
- The reason code for the state change.state-reason-message
- A message that describes the state change.subnet-id
- The ID of the subnet for the instance.tag
:key=value - The key/value combination of a tag assigned to the resource, wheretag
:key is the tag\'s key.tag-key
- The key of a tag assigned to the resource. This filter is independent of thetag-value
filter. For example, if you use both the filter \"tag-key=Purpose\" and the filter \"tag-value=X\", you get any resources assigned both the tag key Purpose (regardless of what the tag\'s value is), and the tag value X (regardless of what the tag\'s key is). If you want to list only resources where Purpose is X, see thetag
:key=value filter.tag-value
- The value of a tag assigned to the resource. This filter is independent of thetag-key
filter.tenancy
- The tenancy of an instance (dedicated
|default
|host
).virtualization-type
- The virtualization type of the instance (paravirtual
|hvm
).vpc-id
- The ID of the VPC that the instance is running in.network-interface.description
- The description of the network interface.network-interface.subnet-id
- The ID of the subnet for the network interface.network-interface.vpc-id
- The ID of the VPC for the network interface.network-interface.network-interface-id
- The ID of the network interface.network-interface.owner-id
- The ID of the owner of the network interface.network-interface.availability-zone
- The Availability Zone for the network interface.network-interface.requester-id
- The requester ID for the network interface.network-interface.requester-managed
- Indicates whether the network interface is being managed by AWS.network-interface.status
- The status of the network interface (available
) |in-use
).network-interface.mac-address
- The MAC address of the network interface.network-interface.private-dns-name
- The private DNS name of the network interface.network-interface.source-dest-check
- Whether the network interface performs source/destination checking. A value oftrue
means checking is enabled, andfalse
means checking is disabled. The value must befalse
for the network interface to perform network address translation (NAT) in your VPC.network-interface.group-id
- The ID of a security group associated with the network interface.network-interface.group-name
- The name of a security group associated with the network interface.network-interface.attachment.attachment-id
- The ID of the interface attachment.network-interface.attachment.instance-id
- The ID of the instance to which the network interface is attached.network-interface.attachment.instance-owner-id
- The owner ID of the instance to which the network interface is attached.network-interface.addresses.private-ip-address
- The private IP address associated with the network interface.network-interface.attachment.device-index
- The device index to which the network interface is attached.network-interface.attachment.status
- The status of the attachment (attaching
|attached
|detaching
|detached
).network-interface.attachment.attach-time
- The time that the network interface was attached to an instance.network-interface.attachment.delete-on-termination
- Specifies whether the attachment is deleted when an instance is terminated.network-interface.addresses.primary
- Specifies whether the IP address of the network interface is the primary private IP address.network-interface.addresses.association.public-ip
- The ID of the association of an Elastic IP address with a network interface.network-interface.addresses.association.ip-owner-id
- The owner ID of the private IP address associated with the network interface.association.public-ip
- The address of the Elastic IP address bound to the network interface.association.ip-owner-id
- The owner of the Elastic IP address associated with the network interface.association.allocation-id
- The allocation ID returned when you allocated the Elastic IP address for your network interface.association.association-id
- The association ID returned when the network interface was associated with an IP address.
#instance_ids ⇒ Array<String>
One or more instance IDs.
Default: Describes all your instances.
#max_results ⇒ Integer
The maximum number of results to return in a single call. To retrieve
the remaining results, make another call with the returned NextToken
value. This value can be between 5 and 1000. You cannot specify this
parameter and the instance IDs parameter or tag filters in the same
call.
#next_token ⇒ String
The token to request the next page of results.


TASI ends Monday at three-month high
Riyadh – Mubasher: The Saudi Stock Exchange (Tadawul) maintained its rising trend for the third consecutive session and ended Monday’s trading in gains, reaching its highest level since last August.
The Tadawul All Share Index (TASI) added 0.26% or 21.27 points and closed the second session of the week at the level of 8,120.01 points.
This is the highest level for the Saudi benchmark index since 28 August.
Traded volumes grew to 160.570 million shares with a turnover of SAR 3.99 billion, through 138,730 transactions.
SISCO was the session’s top gainer, as it gained 4.82%, followed with Sipchem with 4.23%, while Nama led the falling stocks, as it lost 2.84%.
Meanwhile, the main index of the Parallel Market (Nomu) increased by 5.57% and closed 6,552.53 points.
Source: Mubasher Source: {{details.article.source}}


Table of contents Close window
Each subsidiary has to produce two times a year the number of ATM and POS connected and running on the 30 of June and the 31 of December with the following features:
Acquiring channel to be specified: ATM ON SITE, ATM OFF SITE, POS TERMINAL OFF BRANCHES and POS TERMINALS ON SITE. For each channel :
Number of EMV devices
Number of EMV devices running
Number of non EMV devices
Number of non EMV devices running
Availability rate.
*****************


Security Talk: Segurança ágil, simples e automatizada
Tales Casagrande – Sales Engineer
Leo Salone – Sales Engineer
Trend Micro
- Cybersecurity focused for 30+ years
- 6700+ people passionate about security
across 65+ countries
- Leader in Cloud Security
- AWS Advanced Technology Partner since 2012
Cloud and Container Research Team Examples:
- Kubernetes API Server Denial of Service Vulnerability
- Apache Tomcat Remote Code
Execution Vulnerability
- Kubernetes API Proxy Request
Handling Privilege Escalation Vulnerability
State of Open Source Security Report
Fonte: Snyk
Security vs Dev
Delivery
Protect
DEMO Time
({'demo --help' })


This is a landing page with a full screen video background. Feel free to use this landing page in your projects. Keep adding sections etc


Grupo de Inversiones Suramericana is a holding company dedicated to managing a portfolio of investments in a wide range of different economic sectors. .
View UpdatesThe Philippine American Life and General Insurance Company (also commonly known by its trade name, Philam Life) is an insurance company based in the Philippines.
View UpdatesThe Inter-American Development Bank (IADB or IDB or BID) is the largest source of development financing for Latin America and the Caribbean.
View Updates


PinW
Results
Login
×
Close
Enter nickname and password to login
Nickname
Password
Pintron, a pintronic pintronator!
Create a new job!
Title
Text
Cancel
OK


#include <Engine.h>
|
| | Engine (int argc, char **argv, const char *title, const int &windowWidth, const int &windowHeight) |
| |
| virtual void | Run () |
| |
|
|
virtual void | Initialise ()=0 |
| |
|
virtual void | Draw ()=0 |
| |
|
virtual void | Reshape (int w, int h)=0 |
| |
|
virtual void | Update (const double &)=0 |
| |
|
virtual void | HandleKey (unsigned char key, int state, int x, int y)=0 |
| |
|
virtual void | HandleSpecialKey (int key, int state, int x, int y)=0 |
| |
|
virtual void | HandleMouse (int button, int state, int x, int y)=0 |
| |
|
virtual void | HandleMouseDrag (int x, int y)=0 |
| |
|
virtual void | HandleMouseMove (int x, int y)=0 |
| |
|
| static void | InitFunc () |
| |
| static void | DrawFunc () |
| |
| static void | IdleFunc () |
| |
| static void | ResizeFunc (int _width, int _height) |
| |
| static void | KeyDownFunc (unsigned char key, int x, int y) |
| |
| static void | KeyUpFunc (unsigned char key, int x, int y) |
| |
| static void | SpecialKeyDownFunc (int key, int x, int y) |
| |
| static void | SpecialKeyUpFunc (int key, int x, int y) |
| |
| static void | MouseFunc (int button, int state, int x, int y) |
| |
| static void | MouseMotionFunc (int x, int y) |
| |
| static void | PassiveMouseMotionFunc (int x, int y) |
| |
| static int | CheckGLError () |
| |
|
| static Engine * | current = 0 |
| |
|
static const char * | windowTitle = "" |
| |
|
static int | windowID = 0 |
| |
|
static int | windowWidth = 0 |
| |
|
static int | windowHeight = 0 |
| |
|
static int | time = 0 |
| |
Base Engine for the framework. Handles windowing and freeglut/OpenGL contexts. Engine is static.
| Engine::Engine |
( |
int |
argc, |
|
|
char ** |
argv, |
|
|
const char * |
title, |
|
|
const int & |
windowWidth, |
|
|
const int & |
windowHeight |
|
) |
| |
Constructor takes in command line arguments, a title and initial window dimensions.
| int Engine::CheckGLError |
( |
| ) |
|
|
staticprotected |
Iterates through OpenGL error list and dumps error information to console.
Call this method in a draw loop.
| void Engine::DrawFunc |
( |
| ) |
|
|
staticprotected |
Calls Draw and handles double buffering
| Engine * Engine::GetCurrentInstance |
( |
| ) |
|
|
static |
| int Engine::GetWindowHeight |
( |
| ) |
|
|
static |
| int Engine::GetWindowID |
( |
| ) |
|
|
static |
| const char * Engine::GetWindowTitle |
( |
| ) |
|
|
static |
| int Engine::GetWindowWidth |
( |
| ) |
|
|
static |
| void Engine::IdleFunc |
( |
| ) |
|
|
staticprotected |
Checks runtime between successive calls and runs Update before pushing redisplay
| void Engine::InitFunc |
( |
| ) |
|
|
staticprotected |
Sets up default initial functionality for window
| void Engine::KeyDownFunc |
( |
unsigned char |
key, |
|
|
int |
x, |
|
|
int |
y |
|
) |
| |
|
staticprotected |
| void Engine::KeyUpFunc |
( |
unsigned char |
key, |
|
|
int |
x, |
|
|
int |
y |
|
) |
| |
|
staticprotected |
| void Engine::MouseFunc |
( |
int |
button, |
|
|
int |
state, |
|
|
int |
x, |
|
|
int |
y |
|
) |
| |
|
staticprotected |
Handles mouse button click
| void Engine::MouseMotionFunc |
( |
int |
x, |
|
|
int |
y |
|
) |
| |
|
staticprotected |
Handles mouse click and drag (active motion)
| void Engine::PassiveMouseMotionFunc |
( |
int |
x, |
|
|
int |
y |
|
) |
| |
|
staticprotected |
Handles mouse movement (passive motion)
| void Engine::ResizeFunc |
( |
int |
_width, |
|
|
int |
_height |
|
) |
| |
|
staticprotected |
Initial startup method. Sets up GL context and windowing functions to handle drawing, timing and input.
| void Engine::SpecialKeyDownFunc |
( |
int |
key, |
|
|
int |
x, |
|
|
int |
y |
|
) |
| |
|
staticprotected |
Handles special key press
| void Engine::SpecialKeyUpFunc |
( |
int |
key, |
|
|
int |
x, |
|
|
int |
y |
|
) |
| |
|
staticprotected |
Handles special key release
pointer to current window context
The documentation for this class was generated from the following files:
- Framework/Engine/Engine.h
- Framework/Engine/Engine.cpp


Hello Servers!
send
listaddresses
getasset
createtodo
gettodo
assetname
playing
age
get multichain info
createasset
createdasset
{{createdasset}}
createaddress
createdaddress
{{createdaddress}}


Across: 1. He may be beastly rotter, Maxine! (12) 8. Large person has good backing from Fairy Queen (7) 9. Officer shook F-Fisher! (7) 11. Acquainted with radiant saintly Abbess initially, in 20 (10) 12. Post from Lima? (4) 14. Randy Les may be a hero! (8) 16. Northerner in Sue's kimono (6) 17. Tear with blade! (3) 19. Send away graduate with broken shin (6) 21. Ruling party has little time for worker! (8) 24. Punishment said to have killed 26 (4) 25. Teletubby settled here, in French home counties, to engage in party debates (10) 27. Elizabeth follows woman by river to get drink (7) 28. Dress and tour round building (7) 29,10dn. Family advice on moving day or battle orders from one's C.O.? (2 3 3 4 6 3 3) Down: 1. Tex is upset, finishes and pulls out (7) 2. Offer Head compassion (10) 3. Dora crashes on street, returning in car (8) 4. Crazy local goes east around South Africa (6) 5. Top Primate precedes Cross (4) 6. Moira joins G.I. for a spot of paper folding (7) 7. Chairs hold the French fish (12) 10. See 29 13. Plant sap spilt by dictator's daft rat! (10) 15. Free from pride (3) 18. Positive antiparticle may be in iron pots (8) 20. Prior to Al leaving early, we hear no-one is in sister's house (7) 22. Crooked dealing straightened out! (7) 23. Sit upon German in museum (6) 26. First murder victim found in Casa Bellini (4)


{{ block "header" . }}
Deluvi's website
Blog
Games
Github
Itch.io
{{ end }}
{{ block "main" . }} {{ end }}


Add ngMask plugin after your AngularJS.
<script src="angular.min.js"></script>
<script src='ngMask.min.js'></script>
Add ngMask module dependency to your app.
angular.module('yourApp', ['ngMask']);
Use the avaiable patterns to create your mask. Set the mask as input attribute.
<input type='text' ng-model='maskModel' mask='39/19/9999' />
"/" isn't a pattern. It's considered a divisor. Every divisor is automatically written by ngMask. Check all available patterns here.
Adjust your mask options.
<input type='text' ng-model='maskModel ng-value='0/3/9' mask='3/9?' mask-repeat='2' mask-restrict='accept' mask-clean='true' mask-validate='false' mask-limit='false' />
Generated mask '3/9?3/9?'. Check all available options here.
You can make your mask using some patterns available. If you use a pattern not specified below to construct your mask, It'll be considered a divisor. A dividor is a character used to group semantic elements, for example: "/" in dates to separate days, months and years, "-" in SSN to separate area, group and serial numbers or "." in IPv4 to create 4 groups of 8 bits.
NgModel (required): model object
Attribute 'ng-model'The model of input.
Mask (required): mask definition
Attribute 'mask'The mask for input.
NgValue: initial mask value (default: undefined)
Attribute 'ng-value'The initial value of input.
Restrict: 'select', 'reject' or 'accept' (default: select)
Attribute 'mask-restrict' or 'restrict'The way how ngMask will interact with user input. Select restriction: The input will show the char inputted even on error cases. If it has errors, the wrong char will be selected. Reject restriction: The input will show the char inputted on successfull cases. If it has errors, the wrong char will be rejected. Accept restriction: The input will always show the char inputted. No matter it's right or wrong.
Repeat: number - repeat mask n times (default: undefined)
Attribute 'mask-repeat' or 'repeat'Repeats the mask attribute the defined times.
Clean: 'true' or 'false' (default: false)
Attribute 'mask-clean' or 'clean'Cleans model value. Removes divisors from model value.
Validate: 'true' or 'false' (default: true)
Attribute 'mask-validate' or 'validate'Applies validation. Uses form controller setValidity method.
Limit: 'true' or 'false' (default: true)
Attribute 'mask-limit' or 'limit'Limits the max length inputted according with mask.


Promise.OnCancelListener, Promise.OnCompleteListener<RESULT>, Promise.OnFailListener
| Modifier and Type | Field and Description |
|---|---|
protected static TaggedLogger |
LOG |
| Modifier | Constructor and Description |
|---|---|
protected |
AbstractPromise()
Default constructor.
|
protected |
AbstractPromise(java.util.concurrent.Executor executor)
Alternate constructor.
|
| Modifier and Type | Method and Description |
|---|---|
protected void |
abort()
Called when a cancel request is received and before the
OnCancelListener#onCancelled() is called. |
void |
cancel()
Final method.
|
boolean |
isCancelled()
|
boolean |
isDone()
See
Promise.isDone() |
boolean |
isFailed()
|
AbstractPromise<RESULT> |
onCancel(Promise.OnCancelListener listener)
|
AbstractPromise<RESULT> |
onComplete(Promise.OnCompleteListener<RESULT> listener)
|
AbstractPromise<RESULT> |
onFail(Promise.OnFailListener listener)
|
protected abstract RESULT |
result()
Obtain the result for this task.
|
void |
run()
Final method.
|
boolean |
succeeded()
|
protected AbstractPromise()
protected AbstractPromise(java.util.concurrent.Executor executor)
Executor
. For UI use, pass in ThreadPool.foreground()
and save yourself the trouble of View.post(Runnable)
or Activity.runOnUIThread(Runnable)
executor
- executor to execute callbacks on.public final void run()
run
in interface java.lang.Runnable
public final void cancel()
protected abstract RESULT result() throws java.lang.Exception
java.lang.Exception
protected void abort()
OnCancelListener#onCancelled()
is called. If you
are able to abort the execution, this is where you do it. Does nothing by default.public AbstractPromise<RESULT> onComplete(Promise.OnCompleteListener<RESULT> listener)
onComplete
in interface Promise<RESULT>
listener
- listener to notify on completionpublic AbstractPromise<RESULT> onFail(Promise.OnFailListener listener)
public AbstractPromise<RESULT> onCancel(Promise.OnCancelListener listener)
public boolean isDone()
Promise.isDone()
public boolean succeeded()
public boolean isFailed()
public boolean isCancelled()
isCancelled
in interface Promise<RESULT>
true
if task has been cancelled, false
otherwise


IT consulting services
- Build and version control server(jenkins,maven...) setup and consulting.
- Test automation out sourcing.
- Small software development out sourcing.
- Custom software design and development consulting service.
Who may take full advantage of our services?
- The IT company who want to stream line the product build process.
- Start up companies who need technology consultant service to build enterprise IT infrastructure.
- The businesses who want minimize the IT cost.
How it works?
- Contact us by email or phone, and we meet to discuss your needs.
- We offer the price and time to get the job done.
- For big projects, we sign a smaller project to see if the out sourcing qualify your requirement.


Simply fill out the short form above, with information such as where you're moving from and to.
Our system then searches for the highest rated moving companies in your area and displays the results.
Contact these high rated moving companies and move into your new home effortlessly!
+8801683615582
movingcompany@gmail.com


Rain hits normal life
Low-lying areas inundated in Thoothukudi
by Special CorrespondentTHOOTHUKUDI
The widespread rain for almost last 48 hours here halted the normal life resulting in many low-lying areas getting inundated on Sunday.
Residents of St. Mary’s Colony, Lourdu Ammalpuram, Kalaingnar Nagar and Vetrivelpuram among other pockets were the worst hit in the rainfall.
Though the initial showers on Friday were welcome, the continuous rainfall not only hit the normal life, but also forced people to remain indoors.
The early morning rain on Sunday made people tough to reach out to markets and church for the service.
As there was no sign of any rescue operation from the civic authorities, the agitated residents, numbering about 100, including women and children, assembled on Thalamuthu Nagar Road and resorted to a road blockade stir.
On information, Thalamuthu Nagar police station Inspector Thangakrishnan and team rushed to the spot accompanied by Corporation engineers. On holding talks and giving an assurance to pump out the rainwater, the residents dispersed.
As the news spread, DMK MLA Geetha Jeevan visited the residential colony. On seeking assistance from the Collector, a team of officers, including Additional Collector Vishnu Chandran and other officials came to the spot and oversaw the operation.
The civic authorities arranged huge motors to pump out the rainwater and with the help of poclain, the water was channelled out from the road thus bringing relief to the residents.
TANGEDCO officials too received calls from the public on power lines being snapped in some of the streets at Kalaignar Nagar since Saturday night.
The residents urged the Corporation to immediately fill the potholes at least with debris so that the damage caused to the two-wheeler riders were not severe.


Please remember that all the content of the journal you are applying about must be available immediately upon publication.
Copyright & Licensing help


Talk by Stéphane Garnier / @stephaneAG
[ talk given at: AirLiquide-iLab headquarters on: 21/06/2014 ]
Hi !
'name's Stéphane, 27
Coming from a literary background
Briefly studied Applied Arts & Design @LISAA & @Strate
Enjoying "computer stuff" from .. a while now
Doing "global design", aka conceptual/graphic/interactive,
as well as consulting, R&D, & Web/Native Apps cross-platforms
Currently in a "Quest for Lower-level" ( mainly electronics & neuro )
For more infos -> after the talk ? ;p
Codename: "Moldr
"
The project goals are pretty straightforward:
get someone's head scan data
produce a 3D mesh using that data
refine that 3D mesh
generate a mold from it
have that mold 3D-printed
Support is nearly always already available
Specifically, we can split it in 2 major categories:
"PRO" > aka professional product(s)
"DIY" > aka Do-It-Yourself product(s)
3D Scanner > DAVID SLS-2 ( Structured Light )
3D Printer > Leapfrog Creatr ( Fused Filament Fabrication )
[ as for hardware (..) ]
but more exactly:
blablablablabla
blablablablabla
blablablablabla
blablablablabla
blablablablabla
blablablablabla
blablablablabla
blablablablabla
blablablablabla
blablablablabla
blablablablabla
blablablablabla
blablablablabla
blablablablabla
blablablablabla
blablablablabla
blablablablabla
blablablablabla
blablablablabla
blablablablabla
blablablablabla


DECIDE TO FLY™
12400-3 Wake Union Church Rd. PMB #39 Wake Forest, NC 27587
If you're having trouble with the app, checkout our Support Page. We've answered some frequently asked questions that should help you out.
But if that doesn't help... just send an email to our support team at support@decidetofly.com.


Logout
YOUR EMAIL IS NOT CONFIRMED YET, PLEASE CONFIRM IT WITHIN 24H OR YOUR ACCOUNT WILL BE DELETED!
Profile
Explore
New Hive
Chat
My Hives
{% for hive in hives %}
{{ hive.name }}
leave
{% endfor %}


These functions can be used to score candidate tuning parameter combinations as a function of their predicted mean and variation.
prob_improve(trade_off = 0, eps = .Machine$double.eps) exp_improve(trade_off = 0, eps = .Machine$double.eps) conf_bound(kappa = 0.1)
| trade_off | A number or function that describes the trade-off between exploitation and exploration. Smaller values favor exploitation. |
|---|---|
| eps | A small constant to avoid division by zero. |
| kappa | A positive number (or function) that corresponds to the multiplier of the standard deviation in a confidence bound (e.g. 1.96 in normal-theory 95 percent confidence intervals). Smaller values lean more towards exploitation. |
An object of class prob_improve
, exp_improve
, or conf_bounds
along with an extra class of acquisition_function
.
The acquisition functions often combine the mean and variance predictions from the Gaussian process model into an objective to be optimized.
For this documentation, we assume that the metric in question is better when maximized (e.g. accuracy, the coefficient of determination, etc).
The expected improvement of a point x
is based on the predicted mean and
variation at that point as well as the current best value (denoted here as
x_b
). The vignette linked below contains the formulas for this acquisition
function. When the trade_off
parameter is greater than zero, the
acquisition function will down-play the effect of the mean prediction and
give more weight to the variation. This has the effect of searching for new
parameter combinations that are in areas that have yet to be sampled.
Note that for exp_improve()
and prob_improve()
, the trade_off
value is
in the units of the outcome. The functions are parameterized so that the
trade_off
value should always be non-negative.
The confidence bound function does not take into account the current best results in the data.
If a function is passed to exp_improve()
or prob_improve()
, the function
can have multiple arguments but only the first (the current iteration number)
is given to the function. In other words, the function argument should have
defaults for all but the first argument. See expo_decay()
as an example of
a function.
prob_improve()#> Acquisition Function: probability of improvment


public class Seven99
extends java.lang.Object
| Constructor and Description |
|---|
Seven99(java.lang.String fileName)
7/99 Lottery class that takes 7 numbers to guess with a range of 1-99 each number.
|
| Modifier and Type | Method and Description |
|---|---|
int[] |
generate()
Generates the 7 random numbers and stores them into the class.
|
int[] |
getNumbers()
Returns the 7 winning numbers in the class.
|
boolean |
parseFile()
Given the instantiated file stream on the constructor, parses the numbers and checks if it is fit for usage as 7
winning numbers.
|
boolean |
saveNumbers()
Saves the current winning numbers in the class into the file set in the constructor.
|
void |
setNumbers(int[] newNumbers)
Set the winning numbers given a parameter of 7 numbers in an array.
|
public Seven99(java.lang.String fileName)
fileName
- Filename of file to load containing the 7 winning numbers. Numbers are normally comma-separated
values. The file is then opened and a stream of the file is instantiated inside the class.public int[] generate()
public boolean parseFile()
public boolean saveNumbers()
public int[] getNumbers()
public void setNumbers(int[] newNumbers)
newNumbers
- The 7 numbers to be used as winning numbers. Note that we do not check if the numbers are within
ranges.