--- layout: post title: Exploring wasm2cil performance date: 2019-04-30 16:00:00 keywords: front teaser: Very early and very rough comparisons against wasmtime and native ---
(What is wasm2cil? See my previous blog entry.)
I've been trying to do some measurements to get a rough idea of performance for assemblies produced by wasm2cil.
A VERY rough idea. Take these numbers with a grain of salt.
For a rather CPU-intensive test, the following Brotli library:
https://github.com/dropbox/rust-brotli
... makes a nice test case because it compiles to wasm32-unknown-wasi with no problems:
erics-mac-mini:rust-brotli eric$ cargo +nightly build --release --target=wasm32-unknown-wasi
I made a small code change to write out the elapsed time after compressing something.
My test case is measure the time required to compress sqlite3.c (the source code for SQLite in a single 7.4 MB "amalgamation" file).
First, I ran the original Rust version natively:
erics-mac-mini:rust-brotli eric$ cargo run --release --bin brotli -- -c sqlite3.c s1 Finished release [optimized] target(s) in 0.19s Running `target/release/brotli -c sqlite3.c s1` elapsed: 17
Second, I ran brotli.wasm through wasmtime:
erics-mac-mini:wasm2cil eric$ wasmtime --dir=. brotli.wasm -- -c sqlite3.c s1 elapsed: 81
Finally, I ran brotli.wasm through my own wasm2cil:
erics-mac-mini:tool eric$ dotnet run -- run ../brotli.wasm -- -c ../sqlite3.c s1 elapsed: 37
Summarized results:
| Implementation | Elapsed Time (sec) |
|---|---|
| native | 17 |
| wasmtime | 81 |
| wasm2cil | 37 |
So the wasm2cil version takes over twice as long as the native code. Hopefully I can narrow that gap with more focused work on performance.
It's a little surprising that wasmtime came in so much slower. Or maybe it's not. The comparison here has a little bit of apples-to-oranges going on.
First of all, WebAssembly memory accesses are supposed to be range-checked, and wasm2cil isn't currently doing that, while wasmtime probably is.
Second, we're probably seeing a basic difference in maturity between Cranelift JIT (which is fairly young) and .NET Core 2.2.
Third, I could be using wasmtime incorrectly, although I did try the --optimize flag, and it didn't help.
Finally, this is just one benchmark. In the next one, wasmtime does very well indeed.
To do some measurements with SQLite, I wrote a little C program that uses the sqlite3 API to construct a table and query a subset of the rows. Specifically, given parameters (count), (first) and (last), it inserts (count) rows, where each row is two columns, the loop index, and the loop index squared. After the inserts are done, it does a SELECT sum() on the squares column using (first) and (last) as the range of rows.
In other words, the test program uses SQLite to calculate something basically equivalent to this:
int total = 0; for (int i=0; i<count; i++) { if ((i >= first) && (i <= last)) { total += i * i; } }
The main() for this test case allows the count, first and last parameters to be specified on the command line, as well as the name of the sqlite database file. So I did three runs:
1,000 rows; sum the square from 200 through 400
10,000 rows; sum the square from 2,000 through 4,000
100,000 rows; sum the square from 20,000 through 40,000
Here are those runs for the native code:
erics-mac-mini:reference eric$ ./a.out z1 1000 200 400 filename=z1 count=1000 first=200 last=400 elapsed: 472 ms rc: 18766700 erics-mac-mini:reference eric$ ./a.out z2 10000 2000 4000 filename=z2 count=10000 first=2000 last=4000 elapsed: 4618 ms rc:<PHONE_NUMBER> erics-mac-mini:reference eric$ ./a.out z3<PHONE_NUMBER>0 40000 filename=z3 count=100000 first=20000 last=40000 elapsed: 46668 ms rc:<PHONE_NUMBER>
And for wasmtime:
erics-mac-mini:sqlite3 eric$ wasmtime --dir=. sqlite3.wasm -- w1 1000 200 400 filename=w1 count=1000 first=200 last=400 elapsed: 534 ms rc: 18766700 erics-mac-mini:sqlite3 eric$ wasmtime --dir=. sqlite3.wasm -- w2 10000 2000 4000 filename=w2 count=10000 first=2000 last=4000 elapsed: 5292 ms rc:<PHONE_NUMBER> erics-mac-mini:sqlite3 eric$ wasmtime --dir=. sqlite3.wasm -- w3<PHONE_NUMBER>0 40000 filename=w3 count=100000 first=20000 last=40000 elapsed: 53024 ms rc:<PHONE_NUMBER>
And for wasm2cil:
erics-mac-mini:tool eric$ dotnet run -- run ../sqlite3/sqlite3.wasm -- c1 1000 200 400 filename=c1 count=1000 first=200 last=400 elapsed: 1860 ms rc: 18766700 erics-mac-mini:tool eric$ dotnet run -- run ../sqlite3/sqlite3.wasm -- c2 10000 2000 4000 filename=c2 count=10000 first=2000 last=4000 elapsed: 5411 ms rc:<PHONE_NUMBER> erics-mac-mini:tool eric$ dotnet run -- run ../sqlite3/sqlite3.wasm -- c3<PHONE_NUMBER>0 40000 filename=c3 count=100000 first=20000 last=40000 elapsed: 42700 ms rc:<PHONE_NUMBER>
The printed sum result is the same in each case, and the resulting sqlite database files are byte-for-byte identical within each run.
To summarize the results, as elapsed time for each run, in milliseconds:
| Implementation | 1,000 rows | 10,000 rows | 100,000 rows |
|---|---|---|---|
| native | 472 | 4,618 | 46,668 |
| wasmtime | 534 | 5,292 | 53,024 |
| wasm2cil | 1,860 | 5,411 | 42,700 |
Weird.
The results for wasmtime are consistently about 13% higher than native, which is pretty impressive I think.
But the results for wasm2cil are all over the place:
At 1,000 rows, a LOT slower, 394 % of native
At 10,000 rows, a little slower, 117 % of native
At 100,000 rows, a little FASTER, 91 % of native
It seems bizarre for wasm2cil to be faster than the native code for ANY test, so for now I'm going to assume this is a defect in my approach. I did repeat the runs and got similar results each time. So this is an interesting mystery.
There is no bottom line. Not yet.
Well actually, I consider it good news that these test runs work (without crashing or incorrect results), and that timing comparisons are decent (in the same order of magnitude as native).
Beyond that level of precision, I consider this data interesting as long as I'm not drawing big-picture conclusions from it. These results raise more questions than they answer. Mostly I can use the information to guide my efforts to improve wasm2cil.


Fisseha Atsbaha
About Me
Pie Recipe
Movie Review
Responsive web Design Example
Tasks List
JavaScript Demo
Decorate My Text
Below are my study topics for this week.
- Monday: Revise ReactJS, Axios and Redux
- Tuesday: Review Angular 4+
- Wednesday: Spring cloud Layout
- Thursday: AWS for Developers
- Friday: CI/CD Technolgoies
- Saturday: High Availability and High Performance Systems


‘Phoenix Point’ Arrives December 3rd; New Story Trailer Revealed
by Mike WilsonIn a little under two weeks, those hungry for more turn-based strategy in the form of Phoenix Point will be rewarded. To set the tone, developer Snapshot Games have released a new trailer for the game detailing the story.
On top of that, the team also has pre-orders available for the three versions of the game on the Epic Games Store, as well as buy.phoenixpoint.info. Here’s what you’re able to get:
Phoenix Point will be available via the Epic Games Store and the Xbox Game Pass for PC, as well as the Xbox One on December 3rd.


Upload an Image and have fun!
Open the
monitor page to see all the uploads as they happen!
Welcome,
.
Drop files to "Dogeify" here
HTML5 Drop File is not supported on this browser
{{dogeUpload}}


--- layout: post title: Roundup of links date: 2005-03-05 00:00:00 category: personal ---
For various reasons, I anticipate that I shall be rather quiet for the next 4-6 weeks: work is about to step up a gear or three, and this will necessitate cutting back on not-work... So before that, a few links that have accumulated:


| |
NDC Sydney 2017 – SSW's adventures
Last week NDC Sydney (the best .NET conference!)
was back for a second year, and, just as last
year, SSW was very involved in many aspects of the
conference. The highlight was running an entire
track of the conference, as well as live streaming
and recording it. SSW was also part of the code
club, conducted interviews, ran a booth, and
contributed 5 speakers to the event. It was
awesome.
All up, the conference had more than 100 speakers
and more than 150 talks covering 37 technologies,
as well as 13 workshops. In between my duties as
speaker, interviewer and conference partner, I
crammed in as many sessions as I could, caught up
with old friends and met loads of new ones.
Now that it's over but still fresh in my memory,
it's perfect time for a retro:
Keep reading to find out what went well at
NDC
Sydney - and what we'll do better next time.
|
|
|
|
|
Featured video from SSW TV
|
|
|
|
VIDEO: Thank You 15K Subscribers!
SSW TV has just reached 15,000 subscribers
on our YouTube channel!
We would like to take this opportunity to
thank everyone who has subscribed to our
channel and for your ongoing support.
Watch video
|
|
| |
|
|
|
| |
OCT
16
Mon
|
Brisbane, Australia
|
|
OCT
19
Thu
|
Melbourne, Australia
|
|
OCT
20
Fri
|
Sydney, Australia
|
|
| |
|
|
.NET Core is the most powerful and
flexible version ever! Much of the
day-to-day code you write will be the
same - but much of the architecture
and how your project fits together has
changed.
We will provide you with a solid
foundation in .NET Core, an
understanding of why you should be
using .NET Core, and the capability to
build an enterprise application using
the new stack.
Read More
|
|
|
|
| |
|
|
|
Come watch our best Angular devs build an
Angular application from scratch and take it
all the way to an enterprise application
using all the best tools and practices we
use.
Don't waste weeks learning Angular, the
Angular CLI, RxJS, TypeScript, ngrx, NPM,
WebPack, end to end testing and unit
testing. Get jump started in just one day.
Read more
|
NOV
13
MON
|
Brisbane, Australia
|
|
NOV
23
Thu
|
Melbourne, Australia
|
|
NOV
24
Fri
|
Sydney, Australia
|
|
|
|
|
|
|
|
|
Get your hands dirty in this 2 day workshop
as you build your own apps from scratch.
Workshop includes two days tuition with an
experienced Angular 2 developer, full source
code for the three apps you will build for
later reference and to be used as best
practice, and three months subscription to
the FirebootCamp Angular 2 Slack channel.
Read more
|
MAR
1-2
2018
|
Melbourne, Australia
|
|
MAR
5-6
2018
|
Brisbane, Australia
|
|
MAR
8-9
2018
|
Sydney, Australia
|
|
|
|
| |
|
|
|
With the latest release of Angular, there's
even more to learn and love. Angular Hack Days
are free events for beginner and pros alike to
come and share the thrill of creating
something beautiful in a supportive and
friendly environment.
Read More
|
NOV
11
Sat
|
Brisbane, Australia
|
|
NOV
18
Sat
|
Melbourne, Australia
|
|
DEC
2
Sat
|
Sydney, Australia
|
|
|
|
|
|
|
|
|
Xamarin Hack Days are free events that make it
easy for anyone to learn cross-platform
development using Xamarin, a product that
allows you to use .NET/C# to create native
apps that will run across Android, iOS, and
Windows.
Read More
|
SEP
23
Sat
|
Brisbane, Australia
|
|
NOV
25
Sat
|
Melbourne, Australia
|
|
FEB
24
Sat
|
Sydney, Australia
|
|
|
|
| |
September User Group - Sydney
|
| |
Sydney .NET user group: Azure HotShots - The
Azure bits you didn't know you needed to
know - Adam Stephensen & Thiago Passos
Azure is big. Really big. There are more
than 60 different products that make up
Azure and knowing which to invest time in is
a serious challenge. This section gives you
a very brief introduction to the parts of
Azure you may have missed, so that when the
time comes - you know about the tools at
your disposal.
-
App Services - Web Apps, Mobile Apps, API
Apps and Logic Apps
- Azure Functions
-
Data and Storage: SQL Database, DocumentDB
and Azure Storage, SQL Data Warehouse,
Data Factory
-
Azure Automation and Azure Resource
Manager
- API Management
-
Essential networking: Azure Traffic
Manager and DNS
- Azure Bot Service
- Azure Backup & Site Recovery
-
Azure Machine Learning & Cognitive
Services
- Redis Cache & Azure Search
-
Azure Active Directory, AD B2C &
Multi-Factor Authentication
-
Azure Key Vault & Azure Security Center
- Azure Scheduler & Azure Batch
-
Azure Event Hubs & Notification Hubs
- Azure Service Bus
- Azure Service Fabric
- Azure Media Services
- Application Insights
- Azure Advisor
- Azure CDN
-
Machine Learning and Cognitive Services
|
|
|
About the presenters
Adam Stephensen is a
Solution Architect at SSW, Qld General
Manager and head mentor at
FireBootCamp. He loves delivering high
quality, scalable, enterprise
solutions. He has a passion for Scrum,
Continuous Delivery, and software
craftsmanship. This has led him to
mentor and contribute to many .NET
projects across a broad range of
technologies.
Thiago Passos joined
SSW in 2014 as a Senior Software
Architect. He's specialized in
SharePoint and .NET Core, and loves
all aspects of C#, working on windows
and web applications, including
distributed applications and web
services.
|
|
| |
|
|
|
Sep
20
Wed
|
SSW Sydney
Gateway Court Suite 15
81-91 Military Road, Neutral Bay
|
|
|
|
|
|
|
|
|
SSW and Octopus Deploy invite you
to join us for pizza! It's a fun
and delicious opportunity for
networking with peers and sharing
thoughts after the Sydney .NET
User Group.
Read More
|
Sep
20
Wed
|
SSW Sydney
Gateway Court Suite 15
81-91 Military Road, Neutral
Bay
|
|
|
|
|
Sydney .NET User Group and
NerdDinner proudly sponsored by:
|
|
|
|
|
|
|
| |
|
|
|
|
| |
|
SSW is Hiring!
|
|
More SSW jobs
|
|
Systems Administrator
SSW Sydney
SSW is looking for an intelligent person with great
communication skills to be our Systems Administrator to
start ASAP. The ideal candidate will have a minimum of 1
year's commercial experience and know Active Directory,
Windows Server 2008 and above, IIS 8/10, SQL Server,
Microsoft Teams, SharePoint 2016, Azure, TFS 2017, VSTS,
PowerShell, HP SAN administration, PFSense, Office 365
and Exchange 2016.
Read More
|
|
Senior .NET Core and React/Angular
Developer
SSW Brisbane • Sydney • Melbourne
SSW is looking for an enthusiastic Senior .NET Core, Web
API and React/Angular developer to start ASAP. This role
requires great communication skills and solid experience
delivering production-ready web solutions. You should
have MVC experience, but know that these days there is a
better way. Don't worry if you only know Angular 1,
we're experts in teaching people Angular 2 and 4, and
you'll learn fast on the job.
Read More
|
|
|
|
|
Advertise with SSW
|
Unsubscribe
|
Previous SSW Updates
|
Got a Hot Tip to share?
|
Got a comment to make?
|
|


Parameter list for the current execution of FitHiChIP: /home/springer/liang795/projects-in-nathan-lab/HiChip/2021-analysis/HiChip2021/B73-H3K4me3-Loop-HiChip-5000//Parameters.txt
List of CIS interactions within the specified distance thresholds (lower threshold: 20000 upper threshold: 2000000 ): /home/springer/liang795/projects-in-nathan-lab/HiChip/2021-analysis/HiChip2021/B73-H3K4me3-Loop-HiChip-5000//HiCPro_Matrix_BinSize5000/L_20000_U2000000/FitHiChIP.cis.interactions.DistThr.bed
Number of interacting (non zero contacts) bin pairs ( all to all ) : 10002719Bin specific HiChIP coverage, coverage bias, and peak / non-peak boolean values: /home/springer/liang795/projects-in-nathan-lab/HiChip/2021-analysis/HiChip2021/B73-H3K4me3-Loop-HiChip-5000//NormFeatures/Coverage_Bias/FitHiChIP.coverage_Bias.bed
All interactions with their FitHiChIP significance values: /home/springer/liang795/projects-in-nathan-lab/HiChip/2021-analysis/HiChip2021/B73-H3K4me3-Loop-HiChip-5000//FitHiChIP_Peak2ALL_b5000_L20000_U2000000/P2PBckgr_0/Coverage_Bias/FitHiC_BiasCorr/FitHiChIP.interactions_FitHiC.bed
Number of interactions considered: 3558289Significant interactions: /home/springer/liang795/projects-in-nathan-lab/HiChip/2021-analysis/HiChip2021/B73-H3K4me3-Loop-HiChip-5000//FitHiChIP_Peak2ALL_b5000_L20000_U2000000/P2PBckgr_0/Coverage_Bias/FitHiC_BiasCorr/FitHiChIP.interactions_FitHiC_Q0.01.bed
Total number of significant interactions ( FDR 0.01 ) : 73265After merging adjacent loops (connected component modeling) significant interactions: /home/springer/liang795/projects-in-nathan-lab/HiChip/2021-analysis/HiChip2021/B73-H3K4me3-Loop-HiChip-5000//FitHiChIP_Peak2ALL_b5000_L20000_U2000000/P2PBckgr_0/Coverage_Bias/FitHiC_BiasCorr/Merge_Nearby_Interactions/FitHiChIP.interactions_FitHiC_Q0.01_MergeNearContacts.bed
Total number of significant interactions ( FDR 0.01 ) after merging adjacent loops: 6424


Cloud Vision V1 API - Class Google::Longrunning::OperationInfo (v0.6.4)
Reference documentation and code samples for the Cloud Vision V1 API class Google::Longrunning::OperationInfo.
A message representing the message types used by a long-running operation.
Example:
rpc LongRunningRecognize(LongRunningRecognizeRequest) returns (google.longrunning.Operation) { option (google.longrunning.operation_info) = { response_type: "LongRunningRecognizeResponse" metadata_type: "LongRunningRecognizeMetadata" }; }
Inherits
- Object
Extended By
- Google::Protobuf::MessageExts::ClassMethods
Includes
- Google::Protobuf::MessageExts
Methods
#metadata_type
def metadata_type() -> ::String
-
(::String) — Required. The message name of the metadata type for this long-running
operation.
If the response is in a different package from the rpc, a fully-qualified message name must be used (e.g.
google.protobuf.Struct
).Note: Altering this value constitutes a breaking change.
#metadata_type=
def metadata_type=(value) -> ::String
-
value (::String) — Required. The message name of the metadata type for this long-running
operation.
If the response is in a different package from the rpc, a fully-qualified message name must be used (e.g.
google.protobuf.Struct
).Note: Altering this value constitutes a breaking change.
-
(::String) — Required. The message name of the metadata type for this long-running
operation.
If the response is in a different package from the rpc, a fully-qualified message name must be used (e.g.
google.protobuf.Struct
).Note: Altering this value constitutes a breaking change.
#response_type
def response_type() -> ::String
-
(::String) — Required. The message name of the primary return type for this
long-running operation.
This type will be used to deserialize the LRO's response.
If the response is in a different package from the rpc, a fully-qualified message name must be used (e.g.
google.protobuf.Struct
).Note: Altering this value constitutes a breaking change.
#response_type=
def response_type=(value) -> ::String
-
value (::String) — Required. The message name of the primary return type for this
long-running operation.
This type will be used to deserialize the LRO's response.
If the response is in a different package from the rpc, a fully-qualified message name must be used (e.g.
google.protobuf.Struct
).Note: Altering this value constitutes a breaking change.
-
(::String) — Required. The message name of the primary return type for this
long-running operation.
This type will be used to deserialize the LRO's response.
If the response is in a different package from the rpc, a fully-qualified message name must be used (e.g.
google.protobuf.Struct
).Note: Altering this value constitutes a breaking change.


Introduction¶
Welcome to pyfor, a Python module intended for processing large aerial LiDAR (and phodar) acquisitions for the use of large-scale forest inventories. This document serves as a general introduction to the package, its philosophy, and a bit of its history. If you would like to jump straight into analysis, feel free to skip over this “soft” document.
About the Author¶
I am Bryce Frank, a PhD student at Oregon State University. I work for the Forest Measurements and Biometrics Lab, which is run under the guidance of Dr. Temesgen Hailemariam. Our work focuses on developing statistical methodology for the analysis of forest resources at multiple scales. Some of the lab members work on small-scale issues, like biomass and taper modeling. My work, along with others, is focused on producing reliable estimates of forest attributes for large scale forest assessment.
Package History¶
I originally began pyfor as a class project to explore the use of object oriented programming in GIS. At the time, I had been programming in Python for about two years, but still struggled with some concepts like Classes, object inheritance, and the like. pyfor was a way for me to finally learn some of those concepts and implement them in an analysis environment that was useful for me. Around the Spring of 2017, I released the package on GitHub. At the time, the package was in very rough condition, was very inefficient, and only did a few rudimentary tasks.
Around the Spring of 2018 I found a bit of time to rework the package from the ground up. I was deeply inspired by the lidR package, which I used extensively for a few months. I think lidR is a great tool, and pyfor is really just an alternative way of doing many of the same tasks. However, I prefer to work in Python for many reasons, and I also prefer to do my own scripting, so lidR fell by the wayside for me for those reasons. Rather than keep my scripts locked up somewhere, I modified the early version of pyfor with my newest attempts. I am also indebted to Bob McGaughey’s FUSION, which paved the way in terms of these sorts of software, and is still my go-to software package for production work.
Philosophy¶
pyfor started as a means for me to learn OOP, and I think the framework is a very natural way to work with LiDAR data from an interactive standpoint. In this way, pyfor is a bit of a niche tool that is really designed more for research - being able to quickly change parameters on the fly and get quick visual feedback about the results is important for tree detection and other tasks. Because I am a bit selfish when I develop, and I am mainly a researcher at this point in my career, this will be the main objective for the package for the time being.
However, I completely understand the desire for performant processing. As the structure of pyfor beings to solidify, more of my time can be spent on diagnosing performance issues within the package and optimizing toward that end. I think Python, specifically scientific Python packages, will continue to be a solid platform for developing reasonably performant code, if done well. It is unlikely that pyfor will achieve speeds equivalent to raw C++ or FORTRAN code, but I do not think it will be orders of magnitude away if functions are developed in a way that leverages some of these faster packages. This also comes with the benefit of increased maintainability, clarity and usability - goals that I feel are often overlooked in the GIS world.
Acknowledgements¶
A special thank you to Drs. Ben Weinstein, Francisco Mauro-Gutiérrez and Temesgen Hailemariam for their continued support and advice as this project matures.


User registration
First name:
Last name:
Password:
Email:
Phone Number:
Address:
Date of birth:
Upload profile picture:
Update


{% extends 'base.html' %} {% block content %}
An unexpected error has occurred while retrieving your registration entry. Please return to the account profile and try again. If this continues, please report the problem using the contact us link at the bottom of the page.
{% endblock %}


Other people and circumstances can help or hinder you, but it is up to each of us to decide what we want learn, do what we can to learn and make use of new skills in a humane way.


Voluntary Jobs Hub
Please Fill In This Form And Become A Volunteer Today! .
By being one of us, you agree to our Terms & Conditions.


+++ title = "Karpenter" linkTitle = "Karpenter" +++ {{< blocks/cover title="Welcome to Karpenter" image_anchor="top" color="orange" >}}
Karpenter understands cloud instances, and intelligently provisions nodes
{{< blocks/link-down color="info" >}}For most use cases, the entirety of a cluster’s capacity can be managed by a single Karpenter Provisioner. Availability zone, instance type, capacity type, machine image, and scheduling constraints are automatically determined by the controller using a combination of defaults and overrides. Additionally, you can define multiple Provisioners, enabling use cases like isolation, entitlements, and sharding.
Karpenter optimizes for scheduling latency and utilization efficiency using two complementary control loops. First, is the allocator, a fast-acting latency-sensitive controller responsible for ensuring that incoming pods are scheduled as quickly as possible. Second, is the reallocator, a slow-acting cost-sensitive controller that replaces nodes as pods requests and capacity prices shift over time. Together, they maximize the availability and efficiency of your cluster.
Come discuss Karpenter in the #provider-aws channel in the Kubernetes slack!
Note: Reallocation is still in development. Check out the FAQs and Roadmap to learn more.


Warriors, Lovers, and Adventurers
September 23rd
Questions from Last Time
The Journey to the West
Buddhism in the Tang
Xuan Zang
From https://en.wikipedia.org/wiki/File:Xuanzang_w.jpg
Great Tang Records of The Western Regions
大唐西域記
Wu Cheng'en
The Journey to the West
Tang Senzang
Sun Wukong
Zhu Bajie
Sha Wujing
Chapter 1
Chapter 2
Chapter 4
General Discussion
Chapters 5 and 16 for next time


| uiw.event - MATLAB File Help |
Contents of uiw.event package: EventData - Class for providing custom eventdata to listeners KeyboardEvent - Class for eventdata for keyboard actions MouseEvent - Class for eventdata for mouse actions
Copyright 2018-2019 The MathWorks, Inc.


Fishing Guild Member:
In Breka's Stronghold, if you hunt
Breka Orcs, Breka Orc Archers, Breka Orc Warriors, Breka Orc Shaman, or Breka Orc Overlords
, you can get the sweet aromatic fluid the water spirits love.
Back


Welecome to my portfolio
If you're interested by my porfolio you can type "help" to see available commands and get started. Thanks.


An interface to iDigBio's search API that allows downloading specimen records. Searches are returned as a data.frame. Other functions such as the metadata end points return lists of information. iDigBio is a US project focused on digitizing and serving museum specimen collections on the web. See <https://www.idigbio.org> for information on iDigBio.
| Version: | 0.3.5 |
| Depends: | R (≥ 3.0.1) |
| Imports: | stats, plyr, httr, jsonlite |
| Suggests: | testthat |
| Published: | 2017-02-16 |
| Author: | Francois Michonneau [aut, cph], Matthew Collins [aut, cre], Scott Chamberlain [ctb], Kevin Love [ctb], Hem Nalini Morzaria-Luna [ctb] |
| Maintainer: | Matthew Collins <mcollins at acis.ufl.edu> |
| BugReports: | https://github.com/iDigBio/ridigbio/issues |
| License: | MIT + file LICENSE |
| URL: | https://github.com/iDigBio/ridigbio |
| NeedsCompilation: | no |
| Materials: | README |
| CRAN checks: | ridigbio results |
| Reference manual: | ridigbio.pdf |
| Package source: | ridigbio_0.3.5.tar.gz |
| Windows binaries: | r-devel: ridigbio_0.3.5.zip, r-release: ridigbio_0.3.5.zip, r-oldrel: ridigbio_0.3.5.zip |
| OS X binaries: | r-release: ridigbio_0.3.5.tgz, r-oldrel: ridigbio_0.3.5.tgz |
| Old sources: | ridigbio archive |
| Reverse imports: | spocc |
Please use the canonical form https://CRAN.R-project.org/package=ridigbio to link to this page.


|
| string | GridName [get, set] |
| | Grid name which is used if not provided in configuration file. More...
|
| |
| BinaryConfiguration | BinaryConfiguration [get, set] |
| | Gets or sets the binary configuration. More...
|
| |
| ICollection< CacheConfiguration > | CacheConfiguration [get, set] |
| | Gets or sets the cache configuration. More...
|
| |
| string | SpringConfigUrl [get, set] |
| | URL to Spring configuration file. More...
|
| |
| string | JvmDllPath [get, set] |
| | Path jvm.dll file. If not set, it's location will be determined using JAVA_HOME environment variable. If path is neither set nor determined automatically, an exception will be thrown. More...
|
| |
| string | IgniteHome [get, set] |
| | Path to Ignite home. If not set environment variable IGNITE_HOME will be used. More...
|
| |
| string | JvmClasspath [get, set] |
| | Classpath used by JVM on Ignite start. More...
|
| |
| ICollection< string > | JvmOptions [get, set] |
| | Collection of options passed to JVM on Ignite start. More...
|
| |
| ICollection< string > | Assemblies [get, set] |
| | List of additional .Net assemblies to load on Ignite start. Each item can be either fully qualified assembly name, path to assembly to DLL or path to a directory when assemblies reside. More...
|
| |
| bool | SuppressWarnings [get, set] |
| | Whether to suppress warnings. More...
|
| |
| ICollection< ILifecycleBean > | LifecycleBeans [get, set] |
| | Lifecycle beans. More...
|
| |
| int | JvmInitialMemoryMb [get, set] |
| | Initial amount of memory in megabytes given to JVM. Maps to -Xms Java option. More...
|
| |
| int | JvmMaxMemoryMb [get, set] |
| | Maximum amount of memory in megabytes given to JVM. Maps to -Xmx Java option. More...
|
| |
| IDiscoverySpi | DiscoverySpi [get, set] |
| | Gets or sets the discovery service provider. Null for default discovery. More...
|
| |
| ICommunicationSpi | CommunicationSpi [get, set] |
| | Gets or sets the communication service provider. Null for default communication. More...
|
| |
| bool | ClientMode [get, set] |
| | Gets or sets a value indicating whether node should start in client mode. Client node cannot hold data in the caches. More...
|
| |
| ICollection< int > | IncludedEventTypes [get, set] |
| | Gets or sets a set of event types (EventType) to be recorded by Ignite. More...
|
| |
| TimeSpan | MetricsExpireTime [get, set] |
| | Gets or sets the time after which a certain metric value is considered expired. More...
|
| |
| int | MetricsHistorySize [get, set] |
| | Gets or sets the number of metrics kept in history to compute totals and averages. More...
|
| |
| TimeSpan | MetricsLogFrequency [get, set] |
| | Gets or sets the frequency of metrics log print out. TimeSpan.Zero to disable metrics print out. More...
|
| |
| TimeSpan | MetricsUpdateFrequency [get, set] |
| | Gets or sets the job metrics update frequency. TimeSpan.Zero to update metrics on job start/finish. Negative value to never update metrics. More...
|
| |
| int | NetworkSendRetryCount [get, set] |
| | Gets or sets the network send retry count. More...
|
| |
| TimeSpan | NetworkSendRetryDelay [get, set] |
| | Gets or sets the network send retry delay. More...
|
| |
| TimeSpan | NetworkTimeout [get, set] |
| | Gets or sets the network timeout. More...
|
| |
| string | WorkDirectory [get, set] |
| | Gets or sets the work directory. If not provided, a folder under IgniteHome will be used. More...
|
| |
| string | Localhost [get, set] |
| | Gets or sets system-wide local address or host for all Ignite components to bind to. If provided it will override all default local bind settings within Ignite. More...
|
| |
| bool | IsDaemon [get, set] |
| | Gets or sets a value indicating whether this node should be a daemon node. More...
|
| |
| IDictionary< string, object > | UserAttributes [get, set] |
| | Gets or sets the user attributes for this node. More...
|
| |
| AtomicConfiguration | AtomicConfiguration [get, set] |
| | Gets or sets the atomic data structures configuration. More...
|
| |
| TransactionConfiguration | TransactionConfiguration [get, set] |
| | Gets or sets the transaction configuration. More...
|
| |
| bool | IsLateAffinityAssignment [get, set] |
| | Gets or sets a value indicating whether late affinity assignment mode should be used. More...
|
| |
| bool Apache.Ignite.Core.IgniteConfiguration.IsLateAffinityAssignment |
|
getset |
On each topology change, for each started cache, partition-to-node mapping is calculated using AffinityFunction for cache. When late affinity assignment mode is disabled then new affinity mapping is applied immediately.
With late affinity assignment mode, if primary node was changed for some partition, but data for this partition is not rebalanced yet on this node, then current primary is not changed and new primary is temporary assigned as backup. This nodes becomes primary only when rebalancing for all assigned primary partitions is finished. This mode can show better performance for cache operations, since when cache primary node executes some operation and data is not rebalanced yet, then it sends additional message to force rebalancing from other nodes.
Note, that ICacheAffinity interface provides assignment information taking late assignment into account, so while rebalancing for new primary nodes is not finished it can return assignment which differs from assignment calculated by AffinityFunction.
This property should have the same value for all nodes in cluster.
If not provided, default value is DefaultIsLateAffinityAssignment.


/* HashMap.java -- a class providing a basic hashtable data structure, mapping Object --> Object Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc. This file is part of GNU Classpath. GNU Classpath is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GNU Classpath is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GNU Classpath; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. Linking this library statically or dynamically with other modules is making a combined work based on this library. Thus, the terms and conditions of the GNU General Public License cover the whole combination. As a special exception, the copyright holders of this library give you permission to link this library with independent modules to produce an executable, regardless of the license terms of these independent modules, and to copy and distribute the resulting executable under terms of your choice, provided that you also meet, for each linked independent module, the terms and conditions of the license of that module. An independent module is a module which is not derived from or based on this library. If you modify this library, you may extend this exception to your version of the library, but you are not obligated to do so. If you do not wish to do so, delete this exception statement from your version. */ package java.util; import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.io.Serializable; // NOTE: This implementation is very similar to that of Hashtable. If you fix // a bug in here, chances are you should make a similar change to the Hashtable // code. // NOTE: This implementation has some nasty coding style in order to // support LinkedHashMap, which extends this. /** * This class provides a hashtable-backed implementation of the * Map interface. *
 * * It uses a hash-bucket approach; that is, hash collisions are handled * by linking the new node off of the pre-existing node (or list of * nodes). In this manner, techniques such as linear probing (which * can cause primary clustering) and rehashing (which does not fit very * well with Java's method of precomputing hash codes) are avoided. *
 * * Under ideal circumstances (no collisions), HashMap offers O(1) * performance on most operations (containsValue() is, * of course, O(n)). In the worst case (all keys map to the same * hash code -- very unlikely), most operations are O(n). *
 * * HashMap is part of the JDK1.2 Collections API. It differs from * Hashtable in that it accepts the null key and null values, and it * does not support "Enumeration views." Also, it is not synchronized; * if you plan to use it in multiple threads, consider using:
 * Map m = Collections.synchronizedMap(new HashMap(...)); *
 * * The iterators are fail-fast, meaning that any structural * modification, except for remove() called on the iterator * itself, cause the iterator to throw a * ConcurrentModificationException rather than exhibit * non-deterministic behavior. * * @author Jon Zeppieri * @author Jochen Hoenicke * @author Bryce McKinlay * @author Eric Blake<EMAIL_ADDRESS>* @see Object#hashCode() * @see Collection * @see Map * @see TreeMap * @see LinkedHashMap * @see IdentityHashMap * @see Hashtable * @since 1.2 * @status updated to 1.4 */ public class HashMap extends AbstractMap implements Map, Cloneable, Serializable { /** * Default number of buckets. This is the value the JDK 1.3 uses. Some * early documentation specified this value as 101. That is incorrect. * Package visible for use by HashSet. */ static final int DEFAULT_CAPACITY = 11; /** * The default load factor; this is explicitly specified by the spec. * Package visible for use by HashSet. */ static final float DEFAULT_LOAD_FACTOR = 0.75f; /** * Compatible with JDK 1.2. */ private static final long serialVersionUID =<PHONE_NUMBER>63181265L; /** * The rounded product of the capacity and the load factor; when the number * of elements exceeds the threshold, the HashMap calls * rehash(). * @serial the threshold for rehashing */ private int threshold; /** * Load factor of this HashMap: used in computing the threshold. * Package visible for use by HashSet. * @serial the load factor */ final float loadFactor; /** * Array containing the actual key-value mappings. * Package visible for use by nested and subclasses. */ transient HashEntry[] buckets; /** * Counts the number of modifications this HashMap has undergone, used * by Iterators to know when to throw ConcurrentModificationExceptions. * Package visible for use by nested and subclasses. */ transient int modCount; /** * The size of this HashMap: denotes the number of key-value pairs. * Package visible for use by nested and subclasses. */ transient int size; /** * The cache for {@link #entrySet()}. */ private transient Set entries; /** * Class to represent an entry in the hash table. Holds a single key-value * pair. Package visible for use by subclass. * * @author Eric Blake<EMAIL_ADDRESS>*/ static class HashEntry extends AbstractMap.BasicMapEntry { /** * The next entry in the linked list. Package visible for use by subclass. */ HashEntry next; /** * Simple constructor. * @param key the key * @param value the value */ HashEntry(Object key, Object value) { super(key, value); } /** * Called when this entry is accessed via {@link #put(Object, Object)}. * This version does nothing, but in LinkedHashMap, it must do some * bookkeeping for access-traversal mode. */ void access() { } /** * Called when this entry is removed from the map. This version simply * returns the value, but in LinkedHashMap, it must also do bookkeeping. * * @return the value of this key as it is removed */ Object cleanup() { return value; } } /** * Construct a new HashMap with the default capacity (11) and the default * load factor (0.75). */ public HashMap() { this(DEFAULT_CAPACITY, DEFAULT_LOAD_FACTOR); } /** * Construct a new HashMap from the given Map, with initial capacity * the greater of the size of m or the default of 11. *
 * * Every element in Map m will be put into this new HashMap. * * @param m a Map whose key / value pairs will be put into the new HashMap. * NOTE: key / value pairs are not cloned in this constructor. * @throws NullPointerException if m is null */ public HashMap(Map m) { this(Math.max(m.size() * 2, DEFAULT_CAPACITY), DEFAULT_LOAD_FACTOR); putAll(m); } /** * Construct a new HashMap with a specific inital capacity and * default load factor of 0.75. * * @param initialCapacity the initial capacity of this HashMap (>=0) * @throws IllegalArgumentException if (initialCapacity < 0) */ public HashMap(int initialCapacity) { this(initialCapacity, DEFAULT_LOAD_FACTOR); } /** * Construct a new HashMap with a specific inital capacity and load factor. * * @param initialCapacity the initial capacity (>=0) * @param loadFactor the load factor (> 0, not NaN) * @throws IllegalArgumentException if (initialCapacity < 0) || * ! (loadFactor > 0.0) */ public HashMap(int initialCapacity, float loadFactor) { if (initialCapacity < 0) throw new IllegalArgumentException("Illegal Capacity: " + initialCapacity); if (! (loadFactor > 0)) // check for NaN too throw new IllegalArgumentException("Illegal Load: " + loadFactor); if (initialCapacity == 0) initialCapacity = 1; buckets = new HashEntry[initialCapacity]; this.loadFactor = loadFactor; threshold = (int) (initialCapacity * loadFactor); } /** * Returns the number of kay-value mappings currently in this Map. * * @return the size */ public int size() { return size; } /** * Returns true if there are no key-value mappings currently in this Map. * * @return size() == 0 */ public boolean isEmpty() { return size == 0; } /** * Return the value in this HashMap associated with the supplied key, * or null if the key maps to nothing. NOTE: Since the value * could also be null, you must use containsKey to see if this key * actually maps to something. * * @param key the key for which to fetch an associated value * @return what the key maps to, if present * @see #put(Object, Object) * @see #containsKey(Object) */ public Object get(Object key) { int idx = hash(key); HashEntry e = buckets[idx]; while (e != null) { if (equals(key, e.key)) return e.value; e = e.next; } return null; } /** * Returns true if the supplied object equals() a key * in this HashMap. * * @param key the key to search for in this HashMap * @return true if the key is in the table * @see #containsValue(Object) */ public boolean containsKey(Object key) { int idx = hash(key); HashEntry e = buckets[idx]; while (e != null) { if (equals(key, e.key)) return true; e = e.next; } return false; } /** * Puts the supplied value into the Map, mapped by the supplied key. * The value may be retrieved by any object which equals() * this key. NOTE: Since the prior value could also be null, you must * first use containsKey if you want to see if you are replacing the * key's mapping. * * @param key the key used to locate the value * @param value the value to be stored in the HashMap * @return the prior mapping of the key, or null if there was none * @see #get(Object) * @see Object#equals(Object) */ public Object put(Object key, Object value) { int idx = hash(key); HashEntry e = buckets[idx]; while (e != null) { if (equals(key, e.key)) { e.access(); // Must call this for bookkeeping in LinkedHashMap. Object r = e.value; e.value = value; return r; } else e = e.next; } // At this point, we know we need to add a new entry. modCount++; if (++size > threshold) { rehash(); // Need a new hash value to suit the bigger table. idx = hash(key); } // LinkedHashMap cannot override put(), hence this call. addEntry(key, value, idx, true); return null; } /** * Copies all elements of the given map into this hashtable. If this table * already has a mapping for a key, the new mapping replaces the current * one. * * @param m the map to be hashed into this */ public void putAll(Map m) { Iterator itr = m.entrySet().iterator(); while (itr.hasNext()) { Map.Entry e = (Map.Entry) itr.next(); // Optimize in case the Entry is one of our own. if (e instanceof AbstractMap.BasicMapEntry) { AbstractMap.BasicMapEntry entry = (AbstractMap.BasicMapEntry) e; put(entry.key, entry.value); } else put(e.getKey(), e.getValue()); } } /** * Removes from the HashMap and returns the value which is mapped by the * supplied key. If the key maps to nothing, then the HashMap remains * unchanged, and null is returned. NOTE: Since the value * could also be null, you must use containsKey to see if you are * actually removing a mapping. * * @param key the key used to locate the value to remove * @return whatever the key mapped to, if present */ public Object remove(Object key) { int idx = hash(key); HashEntry e = buckets[idx]; HashEntry last = null; while (e != null) { if (equals(key, e.key)) { modCount++; if (last == null) buckets[idx] = e.next; else last.next = e.next; size--; // Method call necessary for LinkedHashMap to work correctly. return e.cleanup(); } last = e; e = e.next; } return null; } /** * Clears the Map so it has no keys. This is O(1). */ public void clear() { if (size != 0) { modCount++; Arrays.fill(buckets, null); size = 0; } } /** * Returns true if this HashMap contains a value o, such that * o.equals(value). * * @param value the value to search for in this HashMap * @return true if at least one key maps to the value * @see containsKey(Object) */ public boolean containsValue(Object value) { for (int i = buckets.length - 1; i >= 0; i--) { HashEntry e = buckets[i]; while (e != null) { if (equals(value, e.value)) return true; e = e.next; } } return false; } /** * Returns a shallow clone of this HashMap. The Map itself is cloned, * but its contents are not. This is O(n). * * @return the clone */ public Object clone() { HashMap copy = null; try { copy = (HashMap) super.clone(); } catch (CloneNotSupportedException x) { // This is impossible. } copy.buckets = new HashEntry[buckets.length]; copy.putAllInternal(this); // Clear the entry cache. AbstractMap.clone() does the others. copy.entries = null; return copy; } /** * Returns a "set view" of this HashMap's keys. The set is backed by the * HashMap, so changes in one show up in the other. The set supports * element removal, but not element addition. * * @return a set view of the keys * @see #values() * @see #entrySet() */ public Set keySet() { if (keys == null) // Create an AbstractSet with custom implementations of those methods // that can be overridden easily and efficiently. keys = new AbstractSet() { public int size() { return size; } public Iterator iterator() { // Cannot create the iterator directly, because of LinkedHashMap. return HashMap.this.iterator(KEYS); } public void clear() { HashMap.this.clear(); } public boolean contains(Object o) { return containsKey(o); } public boolean remove(Object o) { // Test against the size of the HashMap to determine if anything // really got removed. This is necessary because the return value // of HashMap.remove() is ambiguous in the null case. int oldsize = size; HashMap.this.remove(o); return oldsize != size; } }; return keys; } /** * Returns a "collection view" (or "bag view") of this HashMap's values. * The collection is backed by the HashMap, so changes in one show up * in the other. The collection supports element removal, but not element * addition. * * @return a bag view of the values * @see #keySet() * @see #entrySet() */ public Collection values() { if (values == null) // We don't bother overriding many of the optional methods, as doing so // wouldn't provide any significant performance advantage. values = new AbstractCollection() { public int size() { return size; } public Iterator iterator() { // Cannot create the iterator directly, because of LinkedHashMap. return HashMap.this.iterator(VALUES); } public void clear() { HashMap.this.clear(); } }; return values; } /** * Returns a "set view" of this HashMap's entries. The set is backed by * the HashMap, so changes in one show up in the other. The set supports * element removal, but not element addition.
 * * Note that the iterators for all three views, from keySet(), entrySet(), * and values(), traverse the HashMap in the same sequence. * * @return a set view of the entries * @see #keySet() * @see #values() * @see Map.Entry */ public Set entrySet() { if (entries == null) // Create an AbstractSet with custom implementations of those methods // that can be overridden easily and efficiently. entries = new AbstractSet() { public int size() { return size; } public Iterator iterator() { // Cannot create the iterator directly, because of LinkedHashMap. return HashMap.this.iterator(ENTRIES); } public void clear() { HashMap.this.clear(); } public boolean contains(Object o) { return getEntry(o) != null; } public boolean remove(Object o) { HashEntry e = getEntry(o); if (e != null) { HashMap.this.remove(e.key); return true; } return false; } }; return entries; } /** * Helper method for put, that creates and adds a new Entry. This is * overridden in LinkedHashMap for bookkeeping purposes. * * @param key the key of the new Entry * @param value the value * @param idx the index in buckets where the new Entry belongs * @param callRemove whether to call the removeEldestEntry method * @see #put(Object, Object) */ void addEntry(Object key, Object value, int idx, boolean callRemove) { HashEntry e = new HashEntry(key, value); e.next = buckets[idx]; buckets[idx] = e; } /** * Helper method for entrySet(), which matches both key and value * simultaneously. * * @param o the entry to match * @return the matching entry, if found, or null * @see #entrySet() */ // Package visible, for use in nested classes. final HashEntry getEntry(Object o) { if (! (o instanceof Map.Entry)) return null; Map.Entry me = (Map.Entry) o; Object key = me.getKey(); int idx = hash(key); HashEntry e = buckets[idx]; while (e != null) { if (equals(e.key, key)) return equals(e.value, me.getValue()) ? e : null; e = e.next; } return null; } /** * Helper method that returns an index in the buckets array for `key' * based on its hashCode(). Package visible for use by subclasses. * * @param key the key * @return the bucket number */ final int hash(Object key) { return key == null ? 0 : Math.abs(key.hashCode() % buckets.length); } /** * Generates a parameterized iterator. Must be overrideable, since * LinkedHashMap iterates in a different order. * * @param type {@link #KEYS}, {@link #VALUES}, or {@link #ENTRIES} * @return the appropriate iterator */ Iterator iterator(int type) { return new HashIterator(type); } /** * A simplified, more efficient internal implementation of putAll(). clone() * should not call putAll or put, in order to be compatible with the JDK * implementation with respect to subclasses. * * @param m the map to initialize this from */ void putAllInternal(Map m) { Iterator itr = m.entrySet().iterator(); size = 0; while (itr.hasNext()) { size++; Map.Entry e = (Map.Entry) itr.next(); Object key = e.getKey(); int idx = hash(key); addEntry(key, e.getValue(), idx, false); } } /** * Increases the size of the HashMap and rehashes all keys to new * array indices; this is called when the addition of a new value * would cause size() > threshold. Note that the existing Entry * objects are reused in the new hash table. * *
This is not specified, but the new size is twice the current size * plus one; this number is not always prime, unfortunately. */ private void rehash() { HashEntry[] oldBuckets = buckets; int newcapacity = (buckets.length * 2) + 1; threshold = (int) (newcapacity * loadFactor); buckets = new HashEntry[newcapacity]; for (int i = oldBuckets.length - 1; i >= 0; i--) { HashEntry e = oldBuckets[i]; while (e != null) { int idx = hash(e.key); HashEntry dest = buckets[idx]; HashEntry next = e.next; e.next = buckets[idx]; buckets[idx] = e; e = next; } } } /** * Serializes this object to the given stream. * * @param s the stream to write to * @throws IOException if the underlying stream fails * @serialData the capacity(int) that is the length of the * bucket array, the size(int) of the hash map * are emitted first. They are followed by size entries, * each consisting of a key (Object) and a value (Object). */ private void writeObject(ObjectOutputStream s) throws IOException { // Write the threshold and loadFactor fields. s.defaultWriteObject(); s.writeInt(buckets.length); s.writeInt(size); // Avoid creating a wasted Set by creating the iterator directly. Iterator it = iterator(ENTRIES); while (it.hasNext()) { HashEntry entry = (HashEntry) it.next(); s.writeObject(entry.key); s.writeObject(entry.value); } } /** * Deserializes this object from the given stream. * * @param s the stream to read from * @throws ClassNotFoundException if the underlying stream fails * @throws IOException if the underlying stream fails * @serialData the capacity(int) that is the length of the * bucket array, the size(int) of the hash map * are emitted first. They are followed by size entries, * each consisting of a key (Object) and a value (Object). */ private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException { // Read the threshold and loadFactor fields. s.defaultReadObject(); // Read and use capacity, followed by key/value pairs. buckets = new HashEntry[s.readInt()]; int len = s.readInt(); size = len; while (len-- > 0) { Object key = s.readObject(); addEntry(key, s.readObject(), hash(key), false); } } /** * Iterate over HashMap's entries. * This implementation is parameterized to give a sequential view of * keys, values, or entries. * * @author Jon Zeppieri */ private final class HashIterator implements Iterator { /** * The type of this Iterator: {@link #KEYS}, {@link #VALUES}, * or {@link #ENTRIES}. */ private final int type; /** * The number of modifications to the backing HashMap that we know about. */ private int knownMod = modCount; /** The number of elements remaining to be returned by next(). */ private int count = size; /** Current index in the physical hash table. */ private int idx = buckets.length; /** The last Entry returned by a next() call. */ private HashEntry last; /** * The next entry that should be returned by next(). It is set to something * if we're iterating through a bucket that contains multiple linked * entries. It is null if next() needs to find a new bucket. */ private HashEntry next; /** * Construct a new HashIterator with the supplied type. * @param type {@link #KEYS}, {@link #VALUES}, or {@link #ENTRIES} */ HashIterator(int type) { this.type = type; } /** * Returns true if the Iterator has more elements. * @return true if there are more elements * @throws ConcurrentModificationException if the HashMap was modified */ public boolean hasNext() { if (knownMod != modCount) throw new ConcurrentModificationException(); return count > 0; } /** * Returns the next element in the Iterator's sequential view. * @return the next element * @throws ConcurrentModificationException if the HashMap was modified * @throws NoSuchElementException if there is none */ public Object next() { if (knownMod != modCount) throw new ConcurrentModificationException(); if (count == 0) throw new NoSuchElementException(); count--; HashEntry e = next; while (e == null) e = buckets[--idx]; next = e.next; last = e; if (type == VALUES) return e.value; if (type == KEYS) return e.key; return e; } /** * Removes from the backing HashMap the last element which was fetched * with the next() method. * @throws ConcurrentModificationException if the HashMap was modified * @throws IllegalStateException if called when there is no last element */ public void remove() { if (knownMod != modCount) throw new ConcurrentModificationException(); if (last == null) throw new IllegalStateException(); HashMap.this.remove(last.key); last = null; knownMod++; } } }


Why a file server? One of the most common ways to network Linux and Windows computers is to configure Samba as a File Server. This section covers setting up a Samba server to share files with Windows clients.
 To do this server, I’m using a Fedora 33 server OS. Let’s start by installing the packages needed to make our server a Samba file server.
Measure the execution time Measuring the execution time of a script or program is part of a developer’s daily job.
It is not enough to see if it consumes too much memory or too much CPU. We need to see if the software in its entire life cycle is fast enough.
This is because the business logic of any software expects a certain task to be completed with a maximum time established by the programmer himself.
When can a network be considered more or less secure?
Tools to protect yourself There are many tools that are used to protect against external intruders: firewall, fail2ban, vmam.
Firewall In a network the information exchanged can be of various nature and a given node may not always want to allow this information to be visible to all the other nodes in the network or to receive information of any type from the other nodes.
Open philosophy When can a project be defined as open-source? When, as the word says, you open the source code and make it available to other people.
Of course, this is the first concept behind the open-source philosophy. But there is more.
Open source license To make a project open-source first, you need to release it with a certain license. In fact, there are a lot of them. They all share the main philosophy, but differ from each other in small points.


Back
Product Management Links
A Product Manager’s Job
Becoming a Product Manager
User Research
Personas
Product Strategy
Roadmapping
Agile Methodologies
Product Launch
Data and Analytics
Design Sprint
Prototyping
Usability Tests
Working with Engineers
Team Organization
Leadership
Becoming Great
Data and Analytics
Data and analytics show who your users are, what they want, and how to keep them. After you've launched a product, it's important to know which key metrics to track.
Articles
The Four Cringe-Worthy Mistakes Too Many Startups Make with Data
Multiple Authors
I’m Sorry, But Those Are Vanity Metrics
Multiple Authors
SaaS Metrics and Definitions of KPIs from a Growth Hacking Perspective
Tomas Kolafa
Closing the Gap Between Data and Product Development
Multiple Authors
The Only Metric that Matters
Josh Elman
Always be Defining Success
Jackie Bavaro
The Blind Product Manager
Paul Adams
Videos
How Data Will Make You Do Totally the Wrong Thing
Jason Cohen
Dancing Between Data and Intuition, Lessons from Apple & eBay
Dave Lippman
Podcasts
Unique And Interesting Ways Companies Are Using Data
Rocketship.fm
Building Better Products Through Data
Rocketship.fm
Democratizing Data is Product Management
This is Product Management
Books
Data Science for Business
Multiple Authors
Naked Statistics: Stripping the Dread from the Data
Charles Wheelan
Tools
Mixpanel
Fabric
Amplitude
Prodlytic
Tableau


This blog aims to provide a place for me to document crap that is one of
Also, I'm experimenting with github pages


Card title
Some quick example text to build on the card title and make up the bulk of the card's content.
Cras justo odio
Dapibus ac facilisis in
Vestibulum at eros
Card link
Another link


| PostgreSQL 9.0.10 Documentation | ||||
|---|---|---|---|---|
| Prev | Up | Appendix F. Additional Supplied Modules | Next |
The tablefunc module includes various functions that return tables (that is, multiple rows). These functions are useful both in their own right and as examples of how to write C functions that return multiple rows.
Table F-27 shows the functions provided by the tablefunc module.
Table F-27. tablefunc functions
| Function | Returns | Description |
|---|---|---|
normal_rand(int numvals, float8 mean, float8 stddev) | setof float8 | Produces a set of normally distributed random values |
crosstab(text sql) | setof record | Produces a "pivot table" containing row names plus N value columns, where N is determined by the row type specified in the calling query |
crosstabN(text sql) | setof table_crosstab_N | Produces a "pivot table" containing
row names plus N value columns.
crosstab2 , crosstab3 , and
crosstab4 are predefined, but you can create additional
crosstabN functions as described below
|
crosstab(text source_sql, text category_sql) | setof record | Produces a "pivot table" with the value columns specified by a second query |
crosstab(text sql, int N) | setof record | Obsolete version of |
connectby(text relname, text keyid_fld, text parent_keyid_fld
[, text orderby_fld ], text start_with, int max_depth
[, text branch_delim ])
| setof record | Produces a representation of a hierarchical tree structure |
normal_rand
normal_rand(int numvals, float8 mean, float8 stddev) returns setof float8
normal_rand
produces a set of normally distributed random
values (Gaussian distribution).
numvals is the number of values to be returned from the function. mean is the mean of the normal distribution of values and stddev is the standard deviation of the normal distribution of values.
For example, this call requests 1000 values with a mean of 5 and a standard deviation of 3:
test=# SELECT * FROM normal_rand(1000, 5, 3); normal_rand ---------------------- 1.56556322244898 9.10040991424657 5.36957140345079 -0.369151492880995 0.283600703686639 . . . 4.82992125404908 9.71308014517282 2.49639286969028 (1000 rows)
crosstab(text)
crosstab(text sql) crosstab(text sql, int N)
The crosstab
function is used to produce "pivot"
displays, wherein data is listed across the page rather than down.
For example, we might have data like
row1 val11 row1 val12 row1 val13 ... row2 val21 row2 val22 row2 val23 ...
which we wish to display like
row1 val11 val12 val13 ... row2 val21 val22 val23 ... ...
The crosstab
function takes a text parameter that is a SQL
query producing raw data formatted in the first way, and produces a table
formatted in the second way.
The sql parameter is a SQL statement that produces the source set of data. This statement must return one row_name column, one category column, and one value column. N is an obsolete parameter, ignored if supplied (formerly this had to match the number of output value columns, but now that is determined by the calling query).
For example, the provided query might produce a set something like:
row_name cat value ----------+-------+------- row1 cat1 val1 row1 cat2 val2 row1 cat3 val3 row1 cat4 val4 row2 cat1 val5 row2 cat2 val6 row2 cat3 val7 row2 cat4 val8
The crosstab
function is declared to return setof
record, so the actual names and types of the output columns must be
defined in the FROM clause of the calling SELECT
statement, for example:
SELECT * FROM crosstab('...') AS ct(row_name text, category_1 text, category_2 text);
This example produces a set something like:
<== value columns ==> row_name category_1 category_2 ----------+------------+------------ row1 val1 val2 row2 val5 val6
The FROM clause must define the output as one row_name column (of the same data type as the first result column of the SQL query) followed by N value columns (all of the same data type as the third result column of the SQL query). You can set up as many output value columns as you wish. The names of the output columns are up to you.
The crosstab
function produces one output row for each
consecutive group of input rows with the same
row_name value. It fills the output
value columns, left to right, with the
value fields from these rows. If there
are fewer rows in a group than there are output value
columns, the extra output columns are filled with nulls; if there are
more rows, the extra input rows are skipped.
In practice the SQL query should always specify ORDER BY 1,2
to ensure that the input rows are properly ordered, that is, values with
the same row_name are brought together and
correctly ordered within the row. Notice that crosstab
itself does not pay any attention to the second column of the query
result; it's just there to be ordered by, to control the order in which
the third-column values appear across the page.
Here is a complete example:
CREATE TABLE ct(id SERIAL, rowid TEXT, attribute TEXT, value TEXT); INSERT INTO ct(rowid, attribute, value) VALUES('test1','att1','val1'); INSERT INTO ct(rowid, attribute, value) VALUES('test1','att2','val2'); INSERT INTO ct(rowid, attribute, value) VALUES('test1','att3','val3'); INSERT INTO ct(rowid, attribute, value) VALUES('test1','att4','val4'); INSERT INTO ct(rowid, attribute, value) VALUES('test2','att1','val5'); INSERT INTO ct(rowid, attribute, value) VALUES('test2','att2','val6'); INSERT INTO ct(rowid, attribute, value) VALUES('test2','att3','val7'); INSERT INTO ct(rowid, attribute, value) VALUES('test2','att4','val8'); SELECT * FROM crosstab( 'select rowid, attribute, value from ct where attribute = ''att2'' or attribute = ''att3'' order by 1,2') AS ct(row_name text, category_1 text, category_2 text, category_3 text); row_name | category_1 | category_2 | category_3 ----------+------------+------------+------------ test1 | val2 | val3 | test2 | val6 | val7 | (2 rows)
You can avoid always having to write out a FROM clause to define the output columns, by setting up a custom crosstab function that has the desired output row type wired into its definition. This is described in the next section. Another possibility is to embed the required FROM clause in a view definition.
crosstabN(text)
crosstabN(text sql)
The crosstabN
functions are examples of how
to set up custom wrappers for the general crosstab
function,
so that you need not write out column names and types in the calling
SELECT query. The tablefunc module includes
crosstab2
, crosstab3
, and
crosstab4
, whose output row types are defined as
CREATE TYPE tablefunc_crosstab_N AS ( row_name TEXT, category_1 TEXT, category_2 TEXT, . . . category_N TEXT );
Thus, these functions can be used directly when the input query produces
row_name and value columns of type
text, and you want 2, 3, or 4 output values columns.
In all other ways they behave exactly as described above for the
general crosstab
function.
For instance, the example given in the previous section would also work as
SELECT * FROM crosstab3( 'select rowid, attribute, value from ct where attribute = ''att2'' or attribute = ''att3'' order by 1,2');
These functions are provided mostly for illustration purposes. You
can create your own return types and functions based on the
underlying crosstab()
function. There are two ways
to do it:
Create a composite type describing the desired output columns,
similar to the examples in the installation script. Then define a
unique function name accepting one text parameter and returning
setof your_type_name, but linking to the same underlying
crosstab
C function. For example, if your source data
produces row names that are text, and values that are
float8, and you want 5 value columns:
CREATE TYPE my_crosstab_float8_5_cols AS ( my_row_name text, my_category_1 float8, my_category_2 float8, my_category_3 float8, my_category_4 float8, my_category_5 float8 ); CREATE OR REPLACE FUNCTION crosstab_float8_5_cols(text) RETURNS setof my_crosstab_float8_5_cols AS '$libdir/tablefunc','crosstab' LANGUAGE C STABLE STRICT;
Use OUT parameters to define the return type implicitly. The same example could also be done this way:
CREATE OR REPLACE FUNCTION crosstab_float8_5_cols( IN text, OUT my_row_name text, OUT my_category_1 float8, OUT my_category_2 float8, OUT my_category_3 float8, OUT my_category_4 float8, OUT my_category_5 float8) RETURNS setof record AS '$libdir/tablefunc','crosstab' LANGUAGE C STABLE STRICT;
crosstab(text, text)
crosstab(text source_sql, text category_sql)
The main limitation of the single-parameter form of crosstab
is that it treats all values in a group alike, inserting each value into
the first available column. If you want the value
columns to correspond to specific categories of data, and some groups
might not have data for some of the categories, that doesn't work well.
The two-parameter form of crosstab
handles this case by
providing an explicit list of the categories corresponding to the
output columns.
source_sql is a SQL statement that produces the source set of data. This statement must return one row_name column, one category column, and one value column. It may also have one or more "extra" columns. The row_name column must be first. The category and value columns must be the last two columns, in that order. Any columns between row_name and category are treated as "extra". The "extra" columns are expected to be the same for all rows with the same row_name value.
For example, source_sql might produce a set something like:
SELECT row_name, extra_col, cat, value FROM foo ORDER BY 1; row_name extra_col cat value ----------+------------+-----+--------- row1 extra1 cat1 val1 row1 extra1 cat2 val2 row1 extra1 cat4 val4 row2 extra2 cat1 val5 row2 extra2 cat2 val6 row2 extra2 cat3 val7 row2 extra2 cat4 val8
category_sql is a SQL statement that produces the set of categories. This statement must return only one column. It must produce at least one row, or an error will be generated. Also, it must not produce duplicate values, or an error will be generated. category_sql might be something like:
SELECT DISTINCT cat FROM foo ORDER BY 1; cat ------- cat1 cat2 cat3 cat4
The crosstab
function is declared to return setof
record, so the actual names and types of the output columns must be
defined in the FROM clause of the calling SELECT
statement, for example:
SELECT * FROM crosstab('...', '...') AS ct(row_name text, extra text, cat1 text, cat2 text, cat3 text, cat4 text);
This will produce a result something like:
<== value columns ==> row_name extra cat1 cat2 cat3 cat4 ---------+-------+------+------+------+------ row1 extra1 val1 val2 val4 row2 extra2 val5 val6 val7 val8
The FROM clause must define the proper number of output columns of the proper data types. If there are N columns in the source_sql query's result, the first N-2 of them must match up with the first N-2 output columns. The remaining output columns must have the type of the last column of the source_sql query's result, and there must be exactly as many of them as there are rows in the category_sql query's result.
The crosstab
function produces one output row for each
consecutive group of input rows with the same
row_name value. The output
row_name column, plus any "extra"
columns, are copied from the first row of the group. The output
value columns are filled with the
value fields from rows having matching
category values. If a row's category
does not match any output of the category_sql
query, its value is ignored. Output
columns whose matching category is not present in any input row
of the group are filled with nulls.
In practice the source_sql query should always specify ORDER BY 1 to ensure that values with the same row_name are brought together. However, ordering of the categories within a group is not important. Also, it is essential to be sure that the order of the category_sql query's output matches the specified output column order.
Here are two complete examples:
create table sales(year int, month int, qty int); insert into sales values(2007, 1, 1000); insert into sales values(2007, 2, 1500); insert into sales values(2007, 7, 500); insert into sales values(2007, 11, 1500); insert into sales values(2007, 12, 2000); insert into sales values(2008, 1, 1000); select * from crosstab( 'select year, month, qty from sales order by 1', 'select m from generate_series(1,12) m' ) as ( year int, "Jan" int, "Feb" int, "Mar" int, "Apr" int, "May" int, "Jun" int, "Jul" int, "Aug" int, "Sep" int, "Oct" int, "Nov" int, "Dec" int ); year | Jan | Feb | Mar | Apr | May | Jun | Jul | Aug | Sep | Oct | Nov | Dec ------+------+------+-----+-----+-----+-----+-----+-----+-----+-----+------+------ 2007 | 1000 | 1500 | | | | | 500 | | | | 1500 | 2000 2008 | 1000 | | | | | | | | | | | (2 rows)
CREATE TABLE cth(rowid text, rowdt timestamp, attribute text, val text); INSERT INTO cth VALUES('test1','01 March 2003','temperature','42'); INSERT INTO cth VALUES('test1','01 March 2003','test_result','PASS'); INSERT INTO cth VALUES('test1','01 March 2003','volts','2.6987'); INSERT INTO cth VALUES('test2','02 March 2003','temperature','53'); INSERT INTO cth VALUES('test2','02 March 2003','test_result','FAIL'); INSERT INTO cth VALUES('test2','02 March 2003','test_startdate','01 March 2003'); INSERT INTO cth VALUES('test2','02 March 2003','volts','3.1234'); SELECT * FROM crosstab ( 'SELECT rowid, rowdt, attribute, val FROM cth ORDER BY 1', 'SELECT DISTINCT attribute FROM cth ORDER BY 1' ) AS ( rowid text, rowdt timestamp, temperature int4, test_result text, test_startdate timestamp, volts float8 ); rowid | rowdt | temperature | test_result | test_startdate | volts -------+--------------------------+-------------+-------------+--------------------------+-------- test1 | Sat Mar 01 00:00:00 2003 | 42 | PASS | | 2.6987 test2 | Sun Mar 02 00:00:00 2003 | 53 | FAIL | Sat Mar 01 00:00:00 2003 | 3.1234 (2 rows)
You can create predefined functions to avoid having to write out
the result column names and types in each query. See the examples
in the previous section. The underlying C function for this form
of crosstab
is named crosstab_hash.
connectby
connectby(text relname, text keyid_fld, text parent_keyid_fld [, text orderby_fld ], text start_with, int max_depth [, text branch_delim ])
The connectby
function produces a display of hierarchical
data that is stored in a table. The table must have a key field that
uniquely identifies rows, and a parent-key field that references the
parent (if any) of each row. connectby
can display the
sub-tree descending from any row.
Table F-28 explains the parameters.
Table F-28. connectby
parameters
| Parameter | Description |
|---|---|
| relname | Name of the source relation |
| keyid_fld | Name of the key field |
| parent_keyid_fld | Name of the parent-key field |
| orderby_fld | Name of the field to order siblings by (optional) |
| start_with | Key value of the row to start at |
| max_depth | Maximum depth to descend to, or zero for unlimited depth |
| branch_delim | String to separate keys with in branch output (optional) |
The key and parent-key fields can be any data type, but they must be the same type. Note that the start_with value must be entered as a text string, regardless of the type of the key field.
The connectby
function is declared to return setof
record, so the actual names and types of the output columns must be
defined in the FROM clause of the calling SELECT
statement, for example:
SELECT * FROM connectby('connectby_tree', 'keyid', 'parent_keyid', 'pos', 'row2', 0, '~') AS t(keyid text, parent_keyid text, level int, branch text, pos int);
The first two output columns are used for the current row's key and its parent row's key; they must match the type of the table's key field. The third output column is the depth in the tree and must be of type integer. If a branch_delim parameter was given, the next output column is the branch display and must be of type text. Finally, if an orderby_fld parameter was given, the last output column is a serial number, and must be of type integer.
The "branch" output column shows the path of keys taken to reach the current row. The keys are separated by the specified branch_delim string. If no branch display is wanted, omit both the branch_delim parameter and the branch column in the output column list.
If the ordering of siblings of the same parent is important, include the orderby_fld parameter to specify which field to order siblings by. This field can be of any sortable data type. The output column list must include a final integer serial-number column, if and only if orderby_fld is specified.
The parameters representing table and field names are copied as-is
into the SQL queries that connectby
generates internally.
Therefore, include double quotes if the names are mixed-case or contain
special characters. You may also need to schema-qualify the table name.
In large tables, performance will be poor unless there is an index on the parent-key field.
It is important that the branch_delim string
not appear in any key values, else connectby
may incorrectly
report an infinite-recursion error. Note that if
branch_delim is not provided, a default value
of ~ is used for recursion detection purposes.
Here is an example:
CREATE TABLE connectby_tree(keyid text, parent_keyid text, pos int); INSERT INTO connectby_tree VALUES('row1',NULL, 0); INSERT INTO connectby_tree VALUES('row2','row1', 0); INSERT INTO connectby_tree VALUES('row3','row1', 0); INSERT INTO connectby_tree VALUES('row4','row2', 1); INSERT INTO connectby_tree VALUES('row5','row2', 0); INSERT INTO connectby_tree VALUES('row6','row4', 0); INSERT INTO connectby_tree VALUES('row7','row3', 0); INSERT INTO connectby_tree VALUES('row8','row6', 0); INSERT INTO connectby_tree VALUES('row9','row5', 0); -- with branch, without orderby_fld (order of results is not guaranteed) SELECT * FROM connectby('connectby_tree', 'keyid', 'parent_keyid', 'row2', 0, '~') AS t(keyid text, parent_keyid text, level int, branch text); keyid | parent_keyid | level | branch -------+--------------+-------+--------------------- row2 | | 0 | row2 row4 | row2 | 1 | row2~row4 row6 | row4 | 2 | row2~row4~row6 row8 | row6 | 3 | row2~row4~row6~row8 row5 | row2 | 1 | row2~row5 row9 | row5 | 2 | row2~row5~row9 (6 rows) -- without branch, without orderby_fld (order of results is not guaranteed) SELECT * FROM connectby('connectby_tree', 'keyid', 'parent_keyid', 'row2', 0) AS t(keyid text, parent_keyid text, level int); keyid | parent_keyid | level -------+--------------+------- row2 | | 0 row4 | row2 | 1 row6 | row4 | 2 row8 | row6 | 3 row5 | row2 | 1 row9 | row5 | 2 (6 rows) -- with branch, with orderby_fld (notice that row5 comes before row4) SELECT * FROM connectby('connectby_tree', 'keyid', 'parent_keyid', 'pos', 'row2', 0, '~') AS t(keyid text, parent_keyid text, level int, branch text, pos int); keyid | parent_keyid | level | branch | pos -------+--------------+-------+---------------------+----- row2 | | 0 | row2 | 1 row5 | row2 | 1 | row2~row5 | 2 row9 | row5 | 2 | row2~row5~row9 | 3 row4 | row2 | 1 | row2~row4 | 4 row6 | row4 | 2 | row2~row4~row6 | 5 row8 | row6 | 3 | row2~row4~row6~row8 | 6 (6 rows) -- without branch, with orderby_fld (notice that row5 comes before row4) SELECT * FROM connectby('connectby_tree', 'keyid', 'parent_keyid', 'pos', 'row2', 0) AS t(keyid text, parent_keyid text, level int, pos int); keyid | parent_keyid | level | pos -------+--------------+-------+----- row2 | | 0 | 1 row5 | row2 | 1 | 2 row9 | row5 | 2 | 3 row4 | row2 | 1 | 4 row6 | row4 | 2 | 5 row8 | row6 | 3 | 6 (6 rows)
Joe Conway


In Operator
The SQL IN operator is supported in read requests on numeric, date and string parameters by enclosing a comma-separated list in parenthesis. This is used in the GET by Query method.
Examples
- price in 100, 200 or 300: price=(100,200,300)
- rating in G or R: rating=(G,R)
To use a literal ( as the first character in a parameter value, you must escape it with a URL encoded backslash (%5C). For example, the title=%5C(hello
find records with title matching '(hello' (encode as '\(hello').
For Java API usage, prefix the value in a NameValuePair object with the unencoded operator. Zero or more of these are passed in a List
of parameters when creating a Request object with the Factory.


Click all poke and poke back buttons
Close
This tool will allow you to click all poke and poke back buttons at once.
Select time interval between clicks
1 Second
2 Seconds
3 Seconds
4 Seconds
5 Seconds
10 Seconds
15 Seconds
20 Seconds
25 Seconds
30 Seconds
1 Minute
5 Minutes
10 Minutes
20 Minutes
30 Minutes
60 Minutes
Start Clicking


4. Binding Project File¶
Instead of directing the Generator behaviour via command line, the binding developer can write a text project file describing the same information, and avoid the hassle of a long stream of command line arguments.
4.1. The project file structure¶
Here follows a comprehensive example of a generator project file.
[generator-project] generator-set = path/to/generator/CHOICE_GENERATOR header-file = DIR/global.h" /> typesystem-file = DIR/typesystem_for_your_binding.xml output-directory location="OUTPUTDIR" /> include-path = path/to/library/being/wrapped/headers/1 include-path = path/to/library/being/wrapped/headers/2 typesystem-path = path/to/directory/containing/type/system/files/1 typesystem-path = path/to/directory/containing/type/system/files/2 enable-parent-ctor-heuristic
4.2. Project file tags¶
The generator project file tags are in direct relation to the command line arguments. All of the current command line options provided by Shiboken were already seen on the The project file structure, for new command line options provided by additional generator modules (e.g.: qtdoc, Shiboken) could also be used in the generator project file following simple conversion rules.
For tags without options, just write as an empty tag without any attributes. Example:
--BOOLEAN-ARGUMENT
becomes
BOOLEAN-ARGUMENT
and
--VALUE-ARGUMENT=VALUE
becomes
VALUE-ARGUMENT = VALUE


Shopping Cart
Sorry, one or more of the items in your cart is no longer in stock.
{% endif %} {% if cart.cartitem_set.all %}| Item | Price | Quantity |
|---|---|---|
| {{ item.product.name }} | {{ item.unit_price|kishore_currency }} | {% with item.get_form as form %} {% endwith %} |
| Subtotal: {{ cart.total_price|kishore_currency }} |
Your cart is empty.
{% endif %}


Board Meeting Held in Public
Thursday, 26 May 2016, 10:30 am Rooms 401-405, Southside, 105 Victoria Street, London, SW1E 6QT
| ITEMS | ACTION | LEAD | |
|---|---|---|---|
| OPENING REMARKS | |||
| 1. |
Welcome and Introduction
|
- | Chairman |
| 2. |
Minutes of the Previous Meeting
|
Approve | Chairman |
| 3. | Chief Executive’s Report | Inform/ Approve | CEO |
| STRATEGY AND FORWARD VIEW | |||
| 4. | Sustainability and Transformation Plans – update and next steps | ND: CS | |
| 5. | Strategic Framework for Specialised Services | Director of Specialised Services Commissioning | |
| OPERATIONAL PERFORMANCE | |||
| 6. | NHS England Corporate and NHS Performance Report | Review | ND:TCO/ ND:CO |
| 7. | Consolidated 2015/16 year-end financial report | Review | CFO |
| GOVERNANCE | |||
| 8. | NHS England Governance Manual Approval | Approve | ND:TCO |
| 9. | NHS England Complaints Policy Update April 2016 | Approve | ND: TCO |
| 10. | Managing conflicts of interest | Approve | ND:CS |
| 11. | Update on Healthier You: the NHS Diabetes Prevention Programme | Assure | ND:TCO |
| 12. | Update on the NHS England Healthy Workforce Programme | Assure | ND:TCO/CS |
| 13. |
Reports from Board Committees
|
Assure Assure Assure Assure |
Committee Chairs |
| CLOSING REMARKS | |||
| 14. | Any other business | - | Chairman |
| 15. | Resolution to exclude Representatives of the Media and Members of the Public from the Remainder of the Meeting (due to the confidential nature of the business to be transacted) | - | Chairman |
| Board Membership and Attendance | |
|---|---|
| Professor Sir Malcolm Grant | Chairman |
| Simon Stevens | Chief Executive Officer (CEO) |
| David Roberts | Vice-Chairman and Interim Audit & Risk Assurance and Commissioning Committee Chairman |
| Lord Victor Adebowale | Non-Executive Member |
| Professor Sir John Burn | Non-Executive Member |
| Dame Moira Gibb | Non-Executive Member and Investment Committee Chairman |
| Noel Gordon | Non-Executive Member and Specialised Services Commissioning Committee Chairman |
| Michelle Mitchell | Non-Executive Member |
| Richard Barker | Interim National Director: Commissioning Operations (ND: CO) |
| Paul Baumann | Chief Financial Officer (CFO) |
| Jane Cummings | Chief Nursing Officer (CNO) |
| Sir Bruce Keogh | National Medical Director (NMD) |
| Ian Dodge | National Director: Commissioning Strategy (ND:CS) |
| Karen Wheeler | National Director: Transformation and Corporate Operations (ND:TCO) |
| Apologies | |
| Wendy Becker | Non-Executive Member |


Welcome! My name is Carlos.
<Web Developer>
Oakland, CA
Github
Blog
Full Stack Developer
Public Repositories
26
Followers
3
Github Stars
0
Following
4


Bucharest Marathon
Bucharest ROM
Website: bucharest-marathon.com/en
Race Winners
(23 runnings)
2005-2007
03
Oct
2004
05
Oct
2003
06
Oct
2002
06
Oct
2001
21
Oct
2000
22 May 1999
10 Oct 1998
11
Oct
1997
14
Oct
1996
1995
08 Oct
1994
1993
1992
Notes: 1992 is believed to have been the inaugural year.
15 Oct
2017
2:13:13
Duncan Cheruiyot Koech (KEN)
2:42:06
Tiki Gelaneh Erba (ETH)
09 Oct
2016
2:15:05
James Barmasai Kiptum (KEN)
2:40:33
Zeritu Wakjira Begashaw-2
04
Oct 2015
2:13:16
Patrick Kimeli Kiprono (KEN)
(nc)
2:48:52
Zeritu Wakjira Begashaw (ETH)
(nc)
05
Oct 2014
2:13:37
Boaz Kipyego Kipkorir (KEN)
(nc)
2:41:24
Paula-Claudia Todoran (ROM)
(nc)
06
Oct 2013
2:14:05
Victor Busendich Chelokoi (KEN)
(nc)
2:37:28
Tigest Worku Neri (ETH)
(nc)
07
Oct 2012
2:15:19
Felix Kipkorir Kangogo (KEN)
(nc)
2:38:09
Almaz Negede Fekade (ETH)
(nc)
09 Oct
2011
2:17:21
Teklu Geto Metaferia (ETH)
(nc)
2:33:20
Marina Kovalova (RUS)
(nc)
17 Oct 2010
2:13:59
Duncan Cheruiyot Koech (KEN)
(nc)
2:35:13
Svetlana Kouhan (BLR)
(nc)
18 Oct 2009
2:20:35
Eric Yator Cheboi (KEN)
(nc)
2:44:49
Daniela-Elena Cirlan (ROM)
(nc)
12 Oct
2008
2:15:48
Francis Maundu Muendo (KEN)
2:49:52
Valentina Delion-2
---
not held
---
not held
2:22:41
Artur-Ianos Miklos-4 (nc)
2:49:15
Ana Lupan-3 (nc)
2:25:03
Petre Lazarescu (ROM)
(nc)
2:50:11
Ana Lupan-2 (nc)
2:23:02
Artur-Ianos Miklos-3
2:38:50
Ana Lupan (ROM)
2:25:34
Artur-Ianos Miklos-2
---
n/a
2:34:44
Maricel Gaman (ROM)
2:46:08
Maria-Magdalena Teodorascu (ROM)
2:20:37
Artur-Ianos Miklos (ROM)
2:46:43
Valentina Delion (MDA)
2:26:26
Valeriu Vlas (MDA)
(nc)
2:43:55
Florina Pana (ROM)
(nc)
2:29:59
Aleksandr Burtsaylo (UKR)
2:59:36
Ana Nanu (ROM)
2:25:26
Ioan Vaida (ROM)
2:49:02
Constantina Dita (ROM)
2:20:45
Dmitru Tudorie (ROM)
---
n/a
2:21:26
Nikolay Shepelev (MDA) (nc)
2:38:04
Cristina Pomacu (ROM)
(nc)
2:29:36
Gheorghe Sandu (ROM)
---
n/a
2:25:44
Gavril Boitis (ROM)
---
n/a
(nc) => Romanian championship
2015 Sorin Mineran was the Romanian
champion (5th place, 2:35:37)
2015 Paula-Claudia Todoran was the Romanian champion (4th place, 2:52:46)
2014 Sorin Mineran was the Romanian
champion (6th place, 2:30:48)
2013 Stefan-Daniel Lupulescu was the Romanian
champion (5th place, 2:25:25)
2013 Maria-Liliana Danci was the Romanian
champion (5th place, 2:48:54)
2012 Ilie-Alexandru Corneschi was the Romanian
champion (7th place, 2:36:02)
2012 Paula-Claudia Todoran was the Romanian champion (3rd place, 2:48:20)
2011 Gheorge Constantin Surlea was the Romanian champion (5th place,
2:26:33)
2011 Daniela-Elena Cirlan was the Romanian champion (5th place, 2:42:26)
2010 Mircea Marian Sacara was the Romanian champion (8th place,
2:25:42)
2010 Daniela-Elena Cirlan was the Romanian champion (4th place, 2:50:01)
2009 Petra Hristea was the Romanian champion (6th place, 2:27:55)
1998 Valeriu Vlas (MDA) was designated the Romanian champion
1994 Marian Gigea was the Romanian champion (2nd place, 2:21:48)
Most Wins
(1992/date)
Men 4
Artur-Ianos Miklos (ROM)
1999,2001-02,2004
Women
3
Ana Lupan (ROM)
2002-04
Prize Money (ADR qualified runners)
Year Men Women Total
2017 $9,715 $7,110 $16,825
....
2015 6,275 6,160 12,435
2014 7,320 6,630 13,950
2013 7,190 7,530 14,720
2012 8,145 8,145 16,900
....
2008 15,140 8,175 23,315
....
2002 n/a 2,000 2,000
Sums $44,070 $38,640 $82,710
Race Time Bias
(sec/km)
Insufficient data to calculate the race time bias.
Competitive Level (1990-date) Year Men Women 2014 37 22 .... 2011 n/c 139 2010 48 33
Quality Performances
Men <2:14 4 <2:15 8 <2:16 15 <2:17 17 <2:18 24 <2:19 28 <2:20 33 Women <2:34 1 <2:36 2 <2:38 3 <2:40 9 <2:42 18 <2:44 24 <2:46 27 <2:48 32 <2:50 44
Last Updated on 18 Oct 2017
Contributors: Klaas Loonstra (15), Juraj Gasparovic (3 points)


|
|
|
|
|
|
See what others think of JobStreet.com.
Share your side of the story too.
|
|
|
Share your experience by rating them on things like:
|
| Career development |
|
Work/life balance |
| Work environment |
|
Management |
| Benefits and perks |
|
|
|
|
|
Help other job seekers with your invaluable review.
And don't worry, your review will be kept anonymous.
|
|
|
|
Most Trusted
|
|
|
Most Quality Employers
|
|
|
Most Quality Jobs
|
|
|
|
|


--- layout: page title: About header-img: "img/about-bg.png" ---
Just a guy with a knack for simple designs.


NEAR DARK A film review by Mark R. Leeper Copyright 1987 Mark R. Leeper
Capsule review: The worst film I've seen in a theater this year. A vicious gang of vampiric bullies runs wild. Lots of blood and little thought.
What is the nicest thing I can think of to say about NEAR DARK? Well, they didn't bend too much the traditional rules for vampires and within those rules they showed something of how dangerous a gang of really mean- spirited (bloody-minded?) vampires might be. Beyond that, NEAR DARK is over three hours in a film so bad, every minute of watching it counts as two minutes off your sentence.
A guy picks up a girl who turns out to be a vampire. She bites him after what seems like and interminable period of time. This opening sequence turns out to be the high point of the film. Our friend is forced to join the gang of vampires to learn the trade of vampirism. Mostly he sees how the vampires bully and terrorize humans with their powers.  There are a couple of ideas borrowed from Anne Rice's INTERVIEW WITH A VAMPIRE.
Don't waste your time. Life is too short to watch movies this bad. Rate it -2 on the -4 to +4 scale.
Mark R. Leeper ihnp4!mtgzz!leeper<EMAIL_ADDRESS>The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Our new Student_info
class is now quite different from the original Student_info
structure from Chapter 4. Not surprisingly, using the class is different from using the
original structure. After all, our objective was to prevent users from being able to change
our data values, which we accomplished by making them private
. Instead, we intend
for users to write their programs in terms of the interface provided by our class. As an
example, we can rewrite our original main
program from §4.5/70, which wrote the final
grades for the students in a formatted report, to use this version of the class:
int main() { vector<Student_info> students; Student_info record; string::size_type maxlen = 0; // read and store the data while (record.read(cin)) { // changed maxlen = max(maxlen, record.name().size()) // changed students.push_back(record); } // alphabetize the student records sort(students.begin(), students.end(), compare); // write the names and grades for (vector<Student_info>::size_type i = 0; i != students.size(); ++i) { cout << students[i].name() // changed << string(maxlen + 1 - students[i].name.size(), ' '); try { double final_grade = students[i].grade(); // changed streamsize prec = cout.precision(); cout << setprecision(3) << final_grade << setprecision(prec) << endl; } catch (domain_error e) { cout << e.what() << endl; } } return 0; }
The changes here are to the calls of name, read
, and grade
. So, for example, the first
while
loop now says
while (record.read(cin)) {
instead of
while (read(cin, record)) {
Our revised version calls the member read
of the object record
. The earlier version
called the global read
function, passing it record
as an explicit parameter. Both calls
have the same effect: The object record
will be assigned values read from cin
.


Create a directory for the project (TestExtension for example)
Run kango.py with create command:
python kango_dir/kango.py create "path/to/TestExtension"
After running thus commands you will get extension project you can start to edit.
Kango allows you to run Content Scripts on any web page opened by user. Content scripts are running for each webpage shown according to @include / @exclude rules from user js metadata block as follow:
// ==UserScript==
// @name Test
// @include http://*
// ==/UserScript==
All the content scripts should be enumerated in content_scripts section of extension_info.json file.
Lets take a look on content script in work. Create content.js file inside you project common src directory (e.g. TestExtension/src/common) and place follow code in it:
// ==UserScript==
// @name Test
// @include http://*
// ==/UserScript==
var colorNumber = 0;
var colors = ['red', 'green', 'blue'];
window.setInterval(function() {
document.body.style.background = colors[colorNumber++];
if(colorNumber > colors.length) {
colorNumber = 0;
}
}, 1000);
Also add this file in content scripts array in extension_info.json in the same common directory. It should look like:
{
"content_scripts": [
"content.js"
]
}
After building and installing the extension you will see background color blinking on every http webpage you open in your browser.
Background Scripts are running as long as extension is enabled in browser and executed once on each browser start.
Background scripts allows you to use all the Kango APIs in synchronous mode.
Background scripts should be enumerated in background_scripts array of extension_info.json file.
To test it on your own you can create a file named background.js in your common src directory with follow content:
var details = {
method: 'GET',
url: 'http://example.com/',
async: true,
contentType: 'text'
};
kango.xhr.send(details, function(data) {
if(data.status == 200 && data.response != null) {
var text = data.response;
kango.console.log(text);
}
else { // something went wrong
kango.console.log('something went wrong');
}
});
Also add it to extension_info.json like that:
{
"background_scripts": [
"background.js"
]
}
This will download http://example.com/ page and output the content into console.
To add a button to user browser you have to add browser_button section to extension_info.json file like follow:
{
"browser_button": {
"caption": "Kango",
"tooltipText": "Kango",
"icon": "icons/button.png"
}
}
To handle clicks on this button you have to add follow code in one of your background scripts:
kango.ui.browserButton.addEventListener(kango.ui.browserButton.event.COMMAND, function() {
kango.console.log('Button clicked!');
});
You can add a pop-up window to your extension to show on button click. You can open an HTML file in pop-up and access Kango API from it.
To test how popup works create popup.html with follow content:
<html>
<head></head>
<body>
Test
</body>
</html>
and add thus lines to your background script:
kango.ui.browserButton.setPopup({url:'test.html', width: 710, height:510});
Preparing build for your extensions require you to run kango.py with build command as follow:
python kango_dir/kango.py build "path/to/TestExtension"
After running this command you will get output directory filled with extensions builds.


{{'Name'| translate}} *
{{'This is a required field.' | translate}}
{{'Email' | translate}} *
{{'This is a required field.' | translate}}
{{'Username' | translate}} *
{{'This is a required field.' | translate}}
{{ 'Password' | translate }} *
{{'This is a required field.' | translate}}
{{'Password must have more than 5 characters' | translate}}
{{'Confirm password' | translate}} *
{{'This is a required field.' | translate}}
{{'Password must have more than 5 characters' | translate}}


Setup
Test
Preview
Base URL / Authentication : http://localhost:8080
File Upload to S3
Files Meta Information
Sr.No
Request ID
Source Bucket
Original Key
Processed Bucket
Processed Key Key
Date / Time
Image Section
Original
Processed


Daily iron ore update (restock continues)
by Houses and HolesThe charts:
Pretty typical year end retock now. I can’t see prices taking off but relatively firm conditions seem likely now through January, barring an accident.
There are 963 words left in this subscriber-only article.