Returns the revision number of this API
static
integer
getApiRevision
()
Returns an array of known properties (as strings) for the user agent
static
array
getProperties
( &$tree, string $userAgent)
-
array
&$tree: Previously generated tree
-
string
$userAgent: String from the device's User-Agent header
Returns an array of known properties (as typed) for the user agent
static
array
getPropertiesAsTyped
( &$tree, string $userAgent)
-
array
&$tree: Previously generated tree
-
string
$userAgent: string From the device's User-Agent header
Returns a value for the named property for this user agent
static
string
getProperty
( &$tree, string $userAgent, string $property)
-
array
&$tree: Previously generated tree
-
string
$userAgent: String from the device's User-Agent header
-
string
$property: The name of the property to return
Strongly typed property accessor.
Returns a boolean property. (Throws an exception if the property is actually of another type.)
static
boolean
getPropertyAsBoolean
( &$tree, string $userAgent, string $property)
-
array
&$tree: Previously generated tree
-
string
$userAgent: String from the device's User-Agent header
-
string
$property: The name of the property to return
Strongly typed property accessor.
Returns a date property. (Throws an exception if the property is actually of another type.)
static
string
getPropertyAsDate
( &$tree, string $userAgent, string $property)
-
array
&$tree: Previously generated tree
-
string
$userAgent: String from the device's User-Agent header
-
string
$property: The name of the property to return
Strongly typed property accessor.
Returns an integer property. (Throws an exception if the property is actually of another type.)
static
integer
getPropertyAsInteger
( &$tree, string $userAgent, string $property)
-
array
&$tree: Previously generated tree
-
string
$userAgent: String from the device's User-Agent header
-
string
$property: The name of the property to return
Strongly typed property accessor.
Returns a string property. (Throws an exception if the property is actually of another type.)
static
string
getPropertyAsString
( &$tree, string $userAgent, string $property)
-
array
&$tree: Previously generated tree
-
string
$userAgent: String from the device's User-Agent header
-
string
$property: The name of the property to return
Returns a tree from a JSON file.
Use an absolute path name to be sure of success if the current working directory is not clear.
static
array
getTreeFromFile
(string $filename)
-
string
$filename: The location of the file to read in.
Returns a tree from a JSON string
static
array
getTreeFromString
(string $json)
-
string
$json: The string of json data.
Returns the revision number of the tree
static
integer
getTreeRevision
( &$tree)
-
array
&$tree: Previously generated tree
Returns an array of known property names.
Returns all properties available for all user agents in this tree, with their data type names
static
array
listProperties
( &$tree)
-
array
&$tree: Previously generated tree


CarsWorld.com
Login
Login
Sign Up
Log Out
Car Name
Are you sure you want to rent this car?
Yes
No
Home
View Car Collection
Compare Cars
Rent a Car
Driving Test [Required]
Rent Car
Sort By:
Name A-Z
Name Z-A
Rent ↑
Rent ↓


Loading, identifying, aggregating, manipulating, and analysing short tandem repeat regions of massively parallel sequencing data in forensic genetics. 'STRMPS' can work with the package 'STRaitRazoR' (an R interface to the 'STRaitRazor' commandline tool) for added speed. 'STRaitRazoR' only works on linux and can found at <https://github.com/svilsen/STRaitRazoR>. The analyses and framework implemented in this package relies on the papers of Vilsen et al. (2017) <doi:10.1016/j.fsigen.2017.01.017> and Vilsen et al. (2018) <doi:10.1016/j.fsigen.2018.04.003>. Lastly, note that the parallelisation in the package relies on mclapply() and, thus, speed-ups will only be seen on UNIX based systems.
| Version: | 0.5.8 |
| Depends: | R (≥ 3.1.0), Biostrings, ShortRead |
| Imports: | methods, utils, IRanges, tidyr, tibble, dplyr, stringr, purrr, parallel |
| Suggests: | STRaitRazoR |
| Published: | 2018-07-02 |
| Author: | Søren B. Vilsen |
| Maintainer: | Søren B. Vilsen <svilsen at math.aau.dk> |
| License: | MIT + file LICENSE |
| NeedsCompilation: | no |
| CRAN checks: | STRMPS results |
| Reference manual: | STRMPS.pdf |
| Package source: | STRMPS_0.5.8.tar.gz |
| Windows binaries: | r-devel: STRMPS_0.5.8.zip, r-release: STRMPS_0.5.8.zip, r-oldrel: STRMPS_0.5.8.zip |
| OS X binaries: | r-release: not available, r-oldrel: STRMPS_0.5.8.tgz |
Please use the canonical form https://CRAN.R-project.org/package=STRMPS to link to this page.


"Clay Shirky wrote the book Cognitive Surplus in 2010, where he tried to explain the phenomenon of massive user participation and effort into creating content for sites like IcanHazCheezburger. In essence, people in modern society have a lot of spare time and easy access to the tools to create things. Even as adults, many in creative/technical communities seek out opportunities like hackathons and other kinds of jams in order to test crazy ideas that a client would never pay for without proof of concept. My personal experience is that there is a lot of pent up energy that gets released when the right connection is made with the right people and the right idea."
Ed White
Founder of Alloy


Example: Complex Data Flow
Purpose
This example demonstrates how the different data flow components can be used together, simulating a real-life scenario. In this scenario, we will to read some orders from a csv file, lookup the customer key by using the customer name, write the orders into an orders table and also create a customer rating based on the total amount of purchases.
Schematic overview
Preqrequisites
In order to recreate this demo, you need a database server. This example will run on any supported database - though every database comes with some database specific particularities. The following code was succesfully tested with Sql Server.
If you are using docker, you can use the following command to create a docker container for Sql Server:
docker run -e "ACCEPT_EULA=Y" -e "SA_PASSWORD=YourStrong@Passw0rd" -p 1433:1433 --name localmssql -d mcr.microsoft.com/mssql/server
You may need to create a login first, and call docker login
before you can execute this command. The container can be started with docker start localmssql
.
This will create a Sql Server database listening on port 1433 for incoming connections. The sysadmin login has the username sa
with the password YourStrong@Passw0rd
.
You need to create a database called "demo" prior to following this example.
The connection string to connect to this database will look similar like this:
Data Source=.;Initial Catalog=demo;Integrated Security=false;User=sa;password=YourStrong@Passw0rd;
You probably need to adjust the adress to your needs (e.g. replace "." with "<IP_ADDRESS>" to access the database on a different machine).
Preparation
We need to create the destination table orders
and customer_rating as empty table. Also
we want a customer
table that hold a customer key for our customer names.
We could do this manually, or we can use the following ControlFlow Tasks to create these tables:
ControlFlow.DefaultDbConnection = new SqlConnectionManager("Data Source=.;Initial Catalog=demo;Integrated Security=false;User=sa;password=YourStrong@Passw0rd");
TableDefinition OrderDataTableDef = new TableDefinition("orders",
new List<TableColumn>() {
new TableColumn("Key", "int",allowNulls: false, isPrimaryKey:true, isIdentity:true),
new TableColumn("Number","nvarchar(100)", allowNulls: false),
new TableColumn("Item","nvarchar(200)", allowNulls: false),
new TableColumn("Amount","money", allowNulls: false),
new TableColumn("CustomerKey","int", allowNulls: false)
});
TableDefinition CustomerTableDef = new TableDefinition("customer",
new List<TableColumn>() {
new TableColumn("Key", "int",allowNulls: false, isPrimaryKey:true, isIdentity:true),
new TableColumn("Name","nvarchar(200)", allowNulls: false),
});
TableDefinition CustomerRatingTableDef = new TableDefinition("customer_rating",
new List<TableColumn>() {
new TableColumn("Key", "int",allowNulls: false, isPrimaryKey:true, isIdentity:true),
new TableColumn("CustomerKey", "int",allowNulls: false),
new TableColumn("TotalAmount","decimal(10,2)", allowNulls: false),
new TableColumn("Rating","nvarchar(3)", allowNulls: false)
});
//Create demo tables & fill with demo data
OrderDataTableDef.CreateTable();
CustomerTableDef.CreateTable();
CustomerRatingTableDef.CreateTable();
SqlTask.ExecuteNonQuery("Fill customer table", "INSERT INTO customer values('Sandra Kettler')");
SqlTask.ExecuteNonQuery("Fill customer table", "INSERT INTO customer values('Nick Thiemann')");
SqlTask.ExecuteNonQuery("Fill customer table", "INSERT INTO customer values('Zoe Rehbein')");
SqlTask.ExecuteNonQuery("Fill customer table", "INSERT INTO customer values('Margit Gries')");
Let's define some POCOs (Plain old component objects) that can hold the data when it goes through the data flow pipeline.
public class Order
{
public string Number { get; set; }
public string Item { get; set; }
public int CustomerKey { get; set; }
public string CustomerName { get; set; }
public decimal Amount { get; set; }
}
public class Customer
{
[RetrieveColumn(nameof(Order.CustomerKey)]
public int Key { get; set; }
[MatchColumn(nameof(Order.CustomerName)]
public string Name { get; set; }
}
public class Rating
{
[GroupColumn(nameof(Order.CustomerKey)]
public int CustomerKey { get; set; }
[AggregateColumn(nameof(Order.Amount), AggregationMethod.Sum)]
public decimal TotalAmount { get; set; }
[ColumnMap("Rating")]
public string RatingValue => TotalAmount > 50 ? "A" : "F";
}
Please note that there are attributes above the properties. The attributes MatchColumn/RetrieveColumn are used for the LookupTransformation and GroupColumn/AggregationColumn for the Aggregation. They will be explained later.
The ColumnMap
attribute above the property RatingValue
will map the table column Rating
in the customer_rating
table with
corresponding property "RatingValue". Normally, ETLBox maps columns in source or destinations with properties by matching names. So to
make things work by default, the property could have been called "Rating" - but by adding the ColumnMap
attribute, we can define a different
name for the property and let it match with the column "Rating" in the table.
Build the pipeline
Now we can construct a pipeline. Let's start with the source
//Read data from csv file
CsvSource sourceOrderData = new CsvSource("DemoData.csv");
sourceOrderData.Configuration.Delimiter = ";";
Source data will look like this:
OrderNumber;OrderItem;OrderAmount;CustomerName
4711;Yellow Shoes;30.00$;Sandra Kettler
4712;Green T-Shirt;14.99$;Nick Thiemann
4713;Blue Jeans;29.99$;Zoe Rehbein
4714;White Jeans;29.99$;Margit Gries
4807;Green Shoes;32.00$;Margit Gries
We add a row transformation - and connect it with source. Data will be read from the source and moved into the row transformation. A row transformation will go through each row and modifies it by a given function. Furthermore, a row transformation can change the object type of the input into something different - we use this to transform our string array into our POCO.
//Transform into Order object
RowTransformation<ExpandoObject, Order> transIntoObject = new RowTransformation<ExpandoObject, Order>(
csvLine =>
{
dynamic order = csvLine as dynamic;
return new Order()
{
//Header in Csv: OrderNumber;OrderItem;OrderAmount;CustomerName
Number = order.OrderNumber,
Item = order.OrderItem,
Amount = decimal.Parse(order.OrderAmount.ToString().Replace("€",""), CultureInfo.GetCultureInfo("en-US")),
CustomerName = order.CustomerName
};
});
sourceOrderData.LinkTo(transIntoObject);
Automatically converting data types
Note: Normally when reading data from a source, you don't necessarily need use a dynamic object and
then convert it into a regular object using a RowTransformation. Normally, you can do something like
CsvSource<Order> source = new CsvSource<Order>("DemoData.csv");
. All sources and most transformations
will always try to convert the incoming data into the right data types. In our example, it would work if we would
remove the "€"-sign from the amount column in the csv file. Then ETLBox would have been to automatically convert the data
into the right data type.
Retrieving the customer key
Next we want to find a customer key for the customer name in our csv file. To make this work, we already created a customer table that holds a list of customer names and the corresponding keys.
We now define this customer table as a source for our lookup. A lookup will load data from this source to enrich the data in the flow. The customer data will be loaded into the memory as soon as the first rows arrives at the LookupTransformation.
//Find corresponding customer id if customer exists in Customer table
DbSource<Customer> sourceCustomerData = new DbSource<Customer>("customer");
LookupTransformation<Order, Customer> lookupCustomerKey = new LookupTransformation<Order, Customer>(sourceCustomerData);
transIntoObject.LinkTo(lookupCustomerKey);
The lookup works because it can gather the required information from the attributes in the Customer object.
There, we did define a MatchColumn and a RetrieveColumn attribute. The MatchColumn looked like this:
[MatchColumn(nameof(Order.CustomerName)]
and was set on the property "Name". The lookup now knows that any value in the Name
must match the property CustomerName in the incoming Order data. If the values of these two properties matches,
the attribute [RetrieveColumn(nameof(Order.CustomerKey)]
tells the LookupTransformation to push the retrieved value from the source into the property
CustomerKey in the Order.
After an Order row has been processed by the lookup, the property CustomerKey holds the value from the Key column the customer table.
Splitting the data
Now we add a multicast - a multicast "doubles" the input into 2 same outputs with the exact same data. This is useful if you want to have additional destination populated with data based on your input. In our scenario we do this because we not only want to store the orders in a order table, but also we want to create some customer rating based on the orders.
//Split data
Multicast<Order> multiCast = new Multicast<Order>();
lookupCustomerKey.LinkTo(multiCast);
So now let's store the orders with the retrieved customer key in the order table. We need a DbDestination for this.
//Store Order in Orders table
DbDestination<Order> destOrderTable = new DbDestination<Order>("orders");
multiCast.LinkTo(destOrderTable);
Creating the customer rating
The other output will go into an aggregation block to calculate the customer rating. An aggragation is a non-blocking transformation that can do some basic aggregation: Sum, Min, Max and Count. Also, it allows you to group the aggregation functions on one or more values. In our example, we will calculate a rating "A" or "F" based on the total amount of orders - if the total amount is higher than 50, it will be an "A", otherwise "F".
//Create rating for existing customers based total of order amount
Aggregation<Order, Rating> aggregation = new Aggregation<Order, Rating>();
multiCast.LinkTo(aggregation);
It seems that some magic happened in the Aggregation. Let's have a look at the CustomerRating object again:
public class Rating
{
[GroupColumn(nameof(Order.CustomerKey)]
public int CustomerKey { get; set; }
[AggregateColumn(nameof(Order.Amount), AggregationMethod.Sum)]
public decimal TotalAmount { get; set; }
[ColumnMap("Rating")]
public string RatingValue => TotalAmount > 50 ? "A" : "F";
}
The aggrgation gather it's information from the attributes GroupColumn and AggregationColumn. The attribute
[GroupColumn(nameof(Order.CustomerKey)]
on the property CustomerKey tells the aggregation to the Orders by
the CustomerKey and store the grouping value in the Rating result as well. The attribute
[AggregateColumn(nameof(Order.Amount), AggregationMethod.Sum)]
tells the aggregation to do a sum of Amount for each group.
The rating itself is then a simple getter method that checks if the sum of the amount is greater than 50 - if yes, the rating is "A", else "F".
Storing the customer rating
Now we want to store the calculated Rating in the table customer_rating
. So we create another destination
for this table and link it to our BlockTransformation.
//Store the rating in the customer rating table
DbDestination<Rating> destRating = new DbDestination<Rating>("customer_rating");
aggregation.LinkTo(destRating);
The table customer_rating has a column Rating. The attribute [ColumnMap("Rating")]
tells the DbDestination to store the data from the property
RatingValue in the column Rating.
Starting the data flow
No we are all set to start the data flow. We can execute dataflow synchronously or asynchrounously.
Thus, our csv source can to be started with either the Execute()
or ExecuteAsync()
method,
and then we can use the Wait()
or Completion()
method to wait until all destinations
got all data and the completion message from the source.
In our example it looks like this:
//Execute the data flow synchronously
sourceOrderData.Execute();
destOrderTable.Wait();
destRating.Wait();
Checking the result
Now you can connect to your database and look into the tables customer_rating and orders. You will find in there the orders from the csv file, including a customer key as well as a customer rating based on the total amount of purchases.


📅 (2022-09-21 09:45:00 UTC)
# Packages matching: installed # Name # Installed # Synopsis base-bigarray base base-threads base base-unix base conf-findutils 1 Virtual package relying on findutils coq 8.10.2 Formal proof management system num 1.4 The legacy Num library for arbitrary-precision integer and rational arithmetic ocaml 4.09.1 The OCaml compiler (virtual package) ocaml-base-compiler 4.09.1 Official release 4.09.1 ocaml-config 1 OCaml Switch Configuration ocamlfind 1.9.5 A library manager for OCaml # opam file: opam-version: "2.0" maintainer: [ "Érik Martin-Dorel<EMAIL_ADDRESS>"Pierre Roux<EMAIL_ADDRESS>] homepage: "https://sourcesup.renater.fr/validsdp/" dev-repo: "git+https://github.com/validsdp/validsdp.git" bug-reports: "https://github.com/validsdp/validsdp/issues" license: "LGPL-2.1-or-later" build: [ ["sh" "-c" "./configure"] [make "-j%{jobs}%"] ] install: [make "install"] depends: [ "ocaml" "coq" {>= "8.7" & < "8.12~"} "coq-bignums" "coq-flocq" {>= "3.1.0"} "coq-interval" {>= "3.4.0" & < "4~"} "coq-mathcomp-field" {>= "1.8" & < "1.11~"} "coq-libvalidsdp" {= "0.7.0"} "coq-mathcomp-multinomials" {>= "1.2"} "coq-coqeal" {>= "1.0.0"} "coq-paramcoq" {>= "1.1.0"} "osdp" {>= "1.0"} "ocamlfind" {build} "conf-autoconf" {build & dev} ] synopsis: "ValidSDP" description: """ ValidSDP is a library for the Coq formal proof assistant. It provides reflexive tactics to prove multivariate inequalities involving real-valued variables and rational constants, using SDP solvers as untrusted back-ends and verified checkers based on libValidSDP. Once installed, you can import the following modules: From Coq Require Import Reals. From ValidSDP Require Import validsdp. """ tags: [ "keyword:libValidSDP" "keyword:ValidSDP" "keyword:floating-point arithmetic" "keyword:Cholesky decomposition" "category:Miscellaneous/Coq Extensions" "logpath:ValidSDP" ] authors: [ "Érik Martin-Dorel<EMAIL_ADDRESS>"Pierre Roux<EMAIL_ADDRESS>] url { src: "https://github.com/validsdp/validsdp/releases/download/v0.7.0/validsdp-0.7.0.tar.gz" checksum: "sha256=69f7d5f56b0e14bc9b927ff203d8ad8d699134a66b50c60deca58b78074ec1af" }
true
Dry install with the current Coq version:
opam install -y --show-action coq-validsdp.0.7.0 coq.8.10.2
Dry install without Coq/switch base, to test if the problem was incompatibility with the current Coq/OCaml version:
true
opam list; echo; ulimit -Sv 4000000; timeout 4h opam install -y --deps-only coq-validsdp.0.7.0 coq.8.10.2
# Packages matching: installed # Name # Installed # Synopsis base-bigarray base base-threads base base-unix base conf-findutils 1 Virtual package relying on findutils coq 8.10.2 Formal proof management system num 1.4 The legacy Num library for arbitrary-precision integer and rational arithmetic ocaml 4.09.1 The OCaml compiler (virtual package) ocaml-base-compiler 4.09.1 Official release 4.09.1 ocaml-config 1 OCaml Switch Configuration ocamlfind 1.9.5 A library manager for OCaml The following actions will be performed: - install coq-paramcoq 1.1.3+coq8.10 - install conf-gmp 4 - install conf-g++ 1.0 - install coq-bignums 8.10.0 - install coq-mathcomp-ssreflect 1.10.0 - install conf-which 1 - install conf-csdp 1 - install ocamlbuild 0.14.1 - install zarith 1.12 - install coq-flocq 3.4.3 - install coq-mathcomp-fingroup 1.10.0 - install coq-mathcomp-bigenough 1.0.1 - install coq-coquelicot 3.2.0 - install conf-autoconf 0.1 - install coq-mathcomp-algebra 1.10.0 - install coq-mathcomp-finmap 1.4.0 - install coq-interval 3.4.2 - install ocplib-simplex 0.4 - install coq-mathcomp-solvable 1.10.0 - install coq-mathcomp-multinomials 1.5 - install osdp 1.1.0 - install coq-mathcomp-field 1.10.0 - install coq-coqeal 1.0.3 - install coq-libvalidsdp 0.7.0 ===== 24 to install ===== <><> Gathering sources ><><><><><><><><><><><><><><><><><><><><><><><><><><><><> [coq-coquelicot.3.2.0] downloaded from https://coquelicot.gitlabpages.inria.fr/releases/coquelicot-3.2.0.tar.gz [coq-bignums.8.10.0] downloaded from https://github.com/coq/bignums/archive/V8.10.0.tar.gz [coq-coqeal.1.0.3] downloaded from https://github.com/coq-community/coqeal/archive/refs/tags/1.0.3.tar.gz [coq-flocq.3.4.3] downloaded from https://flocq.gitlabpages.inria.fr/releases/flocq-3.4.3.tar.gz [coq-interval.3.4.2] downloaded from https://coqinterval.gitlabpages.inria.fr/releases/interval-3.4.2.tar.gz [coq-libvalidsdp.0.7.0] downloaded from https://github.com/validsdp/validsdp/releases/download/v0.7.0/libvalidsdp-0.7.0.tar.gz [coq-mathcomp-algebra.1.10.0] downloaded from http://github.com/math-comp/math-comp/archive/mathcomp-1.10.0.tar.gz [coq-mathcomp-bigenough.1.0.1] downloaded from https://github.com/math-comp/bigenough/archive/1.0.1.tar.gz [coq-mathcomp-field.1.10.0] downloaded from http://github.com/math-comp/math-comp/archive/mathcomp-1.10.0.tar.gz [coq-mathcomp-fingroup.1.10.0] found in cache [coq-mathcomp-solvable.1.10.0] found in cache [coq-mathcomp-finmap.1.4.0] downloaded from https://github.com/math-comp/finmap/archive/1.4.0.tar.gz [coq-mathcomp-multinomials.1.5] downloaded from https://github.com/math-comp/multinomials/archive/1.5.tar.gz [coq-mathcomp-ssreflect.1.10.0] found in cache [coq-paramcoq.1.1.3+coq8.10] downloaded from https://github.com/coq-community/paramcoq/archive/v1.1.3+coq8.10.tar.gz [ocamlbuild.0.14.1] downloaded from cache at https://opam.ocaml.org/cache [ocplib-simplex.0.4] downloaded from cache at https://opam.ocaml.org/cache [zarith.1.12] downloaded from cache at https://opam.ocaml.org/cache [osdp.1.1.0] downloaded from cache at https://opam.ocaml.org/cache <><> Processing actions <><><><><><><><><><><><><><><><><><><><><><><><><><><><> -> installed conf-csdp.1 -> installed conf-g++.1.0 -> installed conf-gmp.4 -> installed conf-which.1 -> installed conf-autoconf.0.1 -> installed coq-paramcoq.1.1.3+coq8.10 -> installed ocamlbuild.0.14.1 -> installed ocplib-simplex.0.4 -> installed zarith.1.12 -> installed osdp.1.1.0 -> installed coq-bignums.8.10.0 -> installed coq-mathcomp-ssreflect.1.10.0 -> installed coq-mathcomp-bigenough.1.0.1 -> installed coq-mathcomp-finmap.1.4.0 -> installed coq-mathcomp-fingroup.1.10.0 -> installed coq-coquelicot.3.2.0 -> installed coq-mathcomp-algebra.1.10.0 -> installed coq-mathcomp-multinomials.1.5 -> installed coq-flocq.3.4.3 -> installed coq-interval.3.4.2 -> installed coq-coqeal.1.0.3 -> installed coq-mathcomp-solvable.1.10.0 [ERROR] The compilation of coq-mathcomp-field failed at "/home/bench/.opam/opam-init/hooks/sandbox.sh build make -C mathcomp/field -j 4". #=== ERROR while compiling coq-mathcomp-field.1.10.0 ==========================# # context 2.0.6 | linux/x86_64 | ocaml-base-compiler.4.09.1 | file:///home/bench/run/opam-coq-archive/released # path ~/.opam/ocaml-base-compiler.4.09.1/.opam-switch/build/coq-mathcomp-field.1.10.0 # command ~/.opam/opam-init/hooks/sandbox.sh build make -C mathcomp/field -j 4 # exit-code 1 # env-file ~/.opam/log/coq-mathcomp-field-30244-7ab0a7.env # output-file ~/.opam/log/coq-mathcomp-field-30244-7ab0a7.out ### output ### # [...] # File "./closed_field.v", line 892, characters 0-57: # Warning: Duplicate clear of z [duplicate-clear,ssr] # File "./fieldext.v", line 681, characters 2-58: # Warning: Duplicate clear of IH [duplicate-clear,ssr] # File "./fieldext.v", line 681, characters 2-58: # Warning: Duplicate clear of IH [duplicate-clear,ssr] # File "./fieldext.v", line 797, characters 0-46: # Error: System error: "No space left on device" # # make[2]: *** [Makefile.coq:658: fieldext.vo] Error 1 # make[1]: *** [Makefile.coq:321: all] Error 2 # make: *** [../Makefile.comm <><> Error report <><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><> +- The following actions failed | - build coq-mathcomp-field 1.10.0 +- +- The following changes have been performed (the rest was aborted) | - install conf-autoconf 0.1 | - install conf-csdp 1 | - install conf-g++ 1.0 | - install conf-gmp 4 | - install conf-which 1 | - install coq-bignums 8.10.0 | - install coq-coqeal 1.0.3 | - install coq-coquelicot 3.2.0 | - install coq-flocq 3.4.3 | - install coq-interval 3.4.2 | - install coq-mathcomp-algebra 1.10.0 | - install coq-mathcomp-bigenough 1.0.1 | - install coq-mathcomp-fingroup 1.10.0 | - install coq-mathcomp-finmap 1.4.0 | - install coq-mathcomp-multinomials 1.5 | - install coq-mathcomp-solvable 1.10.0 | - install coq-mathcomp-ssreflect 1.10.0 | - install coq-paramcoq 1.1.3+coq8.10 | - install ocamlbuild 0.14.1 | - install ocplib-simplex 0.4 | - install osdp 1.1.0 | - install zarith 1.12 +- # Run eval $(opam env) to update the current shell environment The former state can be restored with: opam switch import "/home/bench/.opam/ocaml-base-compiler.4.09.1/.opam-switch/backup/state-20220920152203.export"
true
No files were installed.
true


| File | Statements | Branches | Functions | Lines | |||||
|---|---|---|---|---|---|---|---|---|---|
| app/ | 65% | 39/60 | 68.97% | 20/29 | 31.58% | 6/19 | 62.96% | 34/54 | |
| app/dialog/ | 60.53% | 23/38 | 100% | 0/0 | 50% | 4/8 | 53.13% | 17/32 | |
| app/home/ | 84.21% | 16/19 | 80% | 4/5 | 75% | 3/4 | 81.25% | 13/16 | |
| app/home/title/ | 100% | 12/12 | 100% | 0/0 | 100% | 3/3 | 100% | 10/10 | |
| app/home/x-large/ | 100% | 6/6 | 80% | 4/5 | 100% | 2/2 | 100% | 4/4 | |
| app/login/ | 61.11% | 22/36 | 28.57% | 2/7 | 33.33% | 4/12 | 60.61% | 20/33 |


--- layout: post type: post status: private tags: [] meta: _edit_last: "1" published: false title: test page --- test


Mourinho Makes EPL Title Prediction
by SL InternationalFormer Chelsea boss Jose Mourinho, who is one of the Premier League's most successful managers of all time with three league titles to his name, has made a prediction as to who he thinks will will win this season's trophy.
Read: Ronaldo Facing Two-Year Ban?
Mourinho enjoyed great success during his two spells with Chelsea, with whom he won three league titles, but the Portuguese manager believes one of the Blues' rivals will claim the coveted Premier League trophy this season.
Speaking ahead of Liverpool's 3-1 win over Manchester City on Sunday, the 56-year-old predicted that the Reds will walk away with the EPL title if they claimed victory over the Citizens.
Earn Airtime & Data With Soccer Laduma's Social Media App - Download Now
"I think (Reds manager) Jurgen (Klopp) cannot say it but I can, I think nine points is, for a very good team, it's a difference that you just have to control," Mourinho said, as reported by the Liverpool Echo.
"So I would say that if Liverpool win the game today (Sunday), they will win the league."
Liverpool ultimately claimed all three points courtesy of goals from Fabinho, Mohamed Salah and Sadio Mane to open up a nine-point gap over City, who were also overtaken in the league standings by Chelsea and Leicester City in the race for this season's title.
Read: 'Pep Could Leave EPL Because Of VAR'
The Reds' next league fixture is against Crystal Palace on 23 November, after the international break.
Do you agree with Mourinho that Liverpool will win the league? Share your thoughts by commenting below.


--- layout: page title: blog post 2 --- {% for blogs in site.data.main.blogpost %}
{{ blogs.date }}
by {{ blogs.author }}
{{ blogs.desc }}


For the best designs, explore and request a custom design just for you and as per your specifications
We don't about you but thre's nothing that makes a home more lovely than good food in a classy kitchen and eaten on an exquisite dinning space.
Sometimes all we want is to rest and what better place? You got it the Lounge-space or better yet the Bedroom
What better place to enjoy your wine and enjoy the view of your homethan the patio WAIT! it gets better you can enjoy all that in your water closet and worry your thoghts away 😜
CLIENT'S MANUAL


A brief aside
This article will be a bit different from all the others so far. While the others have mostly been high-level descriptions of how the X server works, together with interactive demos, today we're going in depth into one of the cool data structures of the X server.
In the first Xplain article, I mentioned a data structure known as the "region", which is a list of rectangles. When I first built Xplain, I took the region code from pixman and compiled it with emscripten, simply because I didn't understand the algorithms. Frankly, I'm terrible at algorithms. I must have looked at tens of different explanations of sorting algorithms over the course of my career, and I still don't understand how they actually work.
For my own fun, I recently decided to investigate the data structures and algorithms behind regions, and I finally understood it. What I found I'm going to share with you.
What are regions?
As mentioned previously, regions are lists of rectangles. You can also think of them as a 1-bit bitmap, where every pixel is either black or white. However, actually storing them as a 1-bit bitmap is expensive, so we use a different representation, which optimizes for common cases, and is more convenient and faster to operate on than large bitmaps.
The X server uses regions all over the place when computing the amount of coverage each window has. So, given the desktop below:
Then the text editor window has as its "visible region" the following L shape.
The X server has to compute these regions efficiently whenever windows are created, destroyed or moved to figure out which window should be painted at which location, and which input should receive mouse events.
The X server has four basic operations it can run on regions:
- When we add two regions together, we produce a union of them. It's as if you took two pieces of cardboard, laid them on top of each other, and then traced that as the resulting region. Perhaps surprisingly, the X server doesn't use this operation very often.
- The area that a window can paint to doesn't include its child windows, since the child windows paint there instead. So, when calculating a window's region, we first intersect with the parent, then subtract out the regions of any children the window has.
- Windows are clipped to their parents. When we want to calculate the region, in absolute space, that a window occupies, we intersect the window's region its parent's.
- When a window changes its shape, we need to paint two areas: space the window occupies that it didn't before, and space the window no longer occupies. Calculating the areas that are different between two regions is known as xor, after the bitwise operator, which can be thought of as calculating which bits differ between two integers.
To get that "L" shaped region of the text editor above, we take the two rectangles of the two windows, subtract the bottom one from the top one, and we have our "L".
What is a region made of?
Before we fully go into these algorithms, let's first go over what a region is. I've previously mentioned it's a "list of rectangles", so let's start with that. For the example region below, there are of course many different lists of rectangles we could make that result in that image.
Are all of these regions? Do our algorithms have to handle all of these cases? It turns out that the answer is "no". A valid region is not just any list of rectangles, but an ordered, minimal set of horizontal bands. What does that mean? Let's work through it. First, let me show you the correct construction of our example region.
OK. The graphics programmers in the room are now smirking. I'll explain why later. But, let's start chewing apart our definition. First up, let's talk about "horizontal bands". A "band" in this case looks like this:
A band is simply a list of rectangles that all start and end at the same Y position. We only have one other rule about the rectangles in a band: they must not touch or overlap. If two rectangles in a band touch or overlap, they can be coalesced into one rectangle. Using these rules, we can "formally" define a band as an "ordered, minimal set of rectangles with the same top and bottom".
A region, it might follow, is simply a bunch of these bands stacked on top of each other. We also make the same rule here: it is not possible for bands to overlap or touch in their top and bottom positions. This can be unintuitive for the case of what look like visibly separate bands. You might imagine that the region below has two bands, but our "overlapping" rule means that it must have three.
Somewhat intuitively, these two rules mean that for one given "bitmap", there is actually only one way to construct it as a region.
Merging bands
With these definitions, let's start constructing our algorithm. First, let's start with the simpler case: two bands with the same tops and bottoms together. For our example, we'll start with union, but we can start generalizing it afterwards.
Since all of the rectangles in a band have the same top and bottom, we only care about the starts and ends of these rectangles on the X axis. I'm going to call these two values "walls". Given that rectangles in our bands do not overlap or touch, it can be intuitive to see that we will always have an even number of these walls, and that the first wall "enters" the region, while the second wall "exits" the region. The third enters, the fourth exits — it's a toggle.
Remember that these two bands have the same tops and bottoms. I'm only putting them on two different Y axes in the demonstration below simply so that you can see them both at the same time, since they do overlap.
Visually, it's very easy to see what the correct union for these two bands would be: 20 and 50. But algorithmically, it can be difficult to figure out what to do.
For future reference, whenever you see a data structure construction like this, with a big focus on slicing up simple geometry into horizontal segments, it's a pretty big hint that we're going to perform a "sweep-line algorithm". These are also sometimes called "scanline" algorithms in the graphics and game development space, and they are so common there, that a lot of game developers I know of first start imagining ways to reduce problems to a scanline algorithm. That's why I said they'd be there, smirking in the background. They've known this trick for decades.
What we're going to do is walk over the walls of both bands at the same time, and then keep track of whether we're inside or outside of the corresponding band. When we transition from being outside both bands to being inside both bands, or vice versa, we output a wall.
function unionBands(bandA, bandB) {
// The resulting band from the union.
var outWalls = [];
// The index into the walls of both.
var iA = 0, iB = 0;
// Whether we're inside either band.
var insideA = false, insideB = false;
while (iA < bandA.numWalls || iB < bandB.numWalls) {
var wallA = bandA.walls[iA];
var wallB = bandB.walls[iB];
// The next wall we want to process is the one on the left,
// that is, the minimum of the two.
var wall = Math.min(wallA, wallB);
// Whether we're outside or inside the bands.
var wasInside = (insideA || insideB);
// Update our state for both bands, and advance to the next wall.
if (wall === wallA) {
iA++;
insideA = !insideA;
}
if (wall === wallB) {
iB++;
insideB = !insideB;
}
// Are we now inside?
var isInside = (insideA || insideB);
// If we're transitioning from inside to outside or outside to
// inside, then output a wall.
if (isInside != wasInside)
outWalls.push(wall);
}
return outWalls;
}
Yes, I know this code is actually broken. In the case where we run out of one set of walls, then we'll
retrieve undefined
from the array, and Math.min
will return NaN
.
This is a complexity that I'm choosing not to deal with in the pseudo-code above.
Let's run through this, visually, in our heads.
- Pick the leftmost wall we haven't encountered. That's the wall on the left, 20. Now we're inside band A. Since we weren't inside either band beforehand, we output a new wall, 20.
- Pick the next wall. That's 30. We're now inside B, but since we were inside A before, we don't emit a wall.
- The next wall is 40. We exit A. Since we're still inside B, we don't emit a wall.
- The next wall is 50. We finally exit B. Since we're no longer inside either band, we emit a wall, at 50.
So it does work!
Implementing other operations
Now we've implemented the basic "union bands" algorithm. What about intersection, subtraction, and xor? Let's
look at intersection first. The core of the algorithm is when we output a wall. For union, we output
a wall when we transition from not being inside either band to being inside either band, or vice versa. For
intersection, we should do it when we change from not being inside both bands to being inside
both bands, and vice versa. So the only code that changes are the values of wasInside
and
isInside
, which become insideA && insideB
. In fact, for all four operations,
there's a boolean test for every one.
In my actual implementation, not being content with ugly closures and, you know, actual code, I implemented each operation as a bitwise trick. But it doesn't have to be that way — all I'm doing is implementing the above four primitive operations a bit more concisely.
Putting it back together
Now we know how to merge bands together. How can we use this to our advantage to merge regions? While you might just start iterating over the bands of each region, and merging them together blindly, we have to be a tad more careful than that. For instance, given the "text editor and kitten" region example we started out with, we might first take the first band of the top region, that being the kitten window, and try to merge it with... well, what, exactly? The other region doesn't have a band there! So now we have to keep track of which regions have bands where, and the code quickly becomes littered with special cases. While we could do this, like the X server does, let's take a different approach.
The issue we're trying to work around is that we sometimes don't have bands to merge in certain cases, which complicates the state tracking of where we are in which region. But the power of computer science is that we can define our own rules. If there's no band where we want, why not make one up? It would be a band with no walls, but if you look closely at the algorithm I've defined above, assuming we fix the issue with running out of walls, it should work for a band with no walls.
This means that a region, in some sense, is defined everywhere. Point to a location anywhere in a region, and I will tell you which band contains it, even if I made the band up.
With that trick, we can simply iterate through all the bands in a region in a similar way. Iterate through bands looking for the one that starts lower, and the one that ends higher, and then merge the walls between them.
function combineBands(bandA, bandB, bandOperation) {
// As above in unionBands, except we take a bandOperation
// which is a function like:
// function(insideA, insideB) { return insideA || insideB; }
// Implementation left as an exercise for the reader. :)
}
function combineRegion(regionA, regionB, bandOperation) {
// A region's bands always starts with:
// { top: -Infinity, bottom: topOfNextBand, walls: [] }
// and it always ends with:
// { top: bottomOfPrevBand, bottom: Infinity, walls: [] }
var newBands = [];
var iA = 0, iB = 0;
while (iA < regionA.bands.length || iB < regionB.bands.length) {
var bandA = regionA.bands[iA];
var bandB = regionB.bands[iB];
var top = Math.max(bandA.top, bandB.top);
var bottom = Math.min(bandA.bottom, bandA.bottom);
var walls = combineBands(bandA, band, bandOperation);
newBands.push({ top: top, bottom: bottom, walls: walls });
if (bottom === bandA.bottom)
iA++;
if (bottom === bandB.bottom)
iB++;
}
return newBands;
}
And this is it! The only tiny thing here left is that sometimes this algorithm might not properly coalesce bands. If we have a union of two regions where one completely engulfs the other, we aren't yet smart enough to take the three resulting bands and merge them into one. That can be fixed by simply checking whether we're about to push a band that has the same properties as the last one; nothing too difficult.
Some Useful Regions...
And that's it! That's all you need to know about regions — how they're constructed, how they're operated with, and how they're used in the X server!
But you might be wondering, where might have I encountered regions before? Regions don't tend to be used very often, but you might notice their tell-tale signs. The most useful region you've encountered would be the 1-bit rounded border region. You know, it looks like this:
Before the desktop world had the Composite extension for true transparency, we used regions like this to simulate having rounded corners. But, of course, it was terribly sampled. Some applications, like Chromium, actually still do this in their own window decorations.
I have also mentioned that regions are an optimization of a 1-bit bitmap with different semantics. While bitmaps scale linearly with their size, regions however scale with the number of bands and walls: that is, how many times we toggle the region on and off. You can already imagine what the worst case for a region data might be.
It's a checkerboard. Each pixel in here has two walls. Each "on" pixel is two walls, and each row is its own band, so assuming that we use 32-bit numbers for the positions, 8 bytes per pixel, and 8 extra bytes per band to store the top and bottom. Since is checkerboard is 16x10, that means we have (16*4+8) bytes = 72 bytes per band, and we have ten of them, for 720 bytes. In a bitmap, each row could be packed into two bytes, for a total of 20 bytes. Yeesh.
Enlightenment used to use checkerboard regions like these to fake transparency, along with other tricks like copying the front buffer to its own windows. The Xorg of the day tended to crumble under the weight of such regions and tricks, but it was an important part of history that let us figure out how to move forward. As the COMPOSITE extension specification puts it, "clever hacks are an awfully close substitute for changes in the underlying system".
Window shapes, both on the output and input sides, are clearly the most useful case for complex regions like this. You likely won't need to write a window system like this any time soon. But I think the simplicity of the data structures and algorithms in play here are something we can all take lessons from. This isn't a constructed algorithms class example, this is a real example from real code to solve a real problem.
Next time...
I know, I know. I've been particularly bad at writing new entries to this series. One might assume it's because of a lack of time, or because I'm just "too busy with real work", but the reality is that I have plenty of time. I simply, have, until recently, lacked the motivation to sit down and finish an article. It's especially hard since I've chosen such a niche audience, that I'm disappointed when it doesn't get more recognition than it does.
This is a labor of love project for me. I get an incredible joy out of explaining things and turning them inside out; turning the esoteric and archaic into something accessible and fun. I'm not an incredible programmer by any means. If you've enjoyed this series thus far and want me to continue, the best way to do it would be to tell me you appreciated it. Send me questions, perhaps fix a few of my silly typos in a pull request. Nothing inspires me more than knowing I helped somebody, and that people are enjoying my work.
Recently, a handful of you have reached out, and because of that, I've picked this series back up again. I had a lot of fun writing the text and code for this article, and I've already started the next. It's "Expert Window Techniques", which covers the practical ways of combining X11's toolbox of windows to construct a working desktop environment. We'll go over window managers, taskbars, the ICCCM, the Extended Window Manager Hints, and all of that fun jazz. I can't promise a deadline for it, and I won't even make vague statements like "by the end of the year". It'll come out when I'm happy with it, when I'm motivated enough to complete it.
Thank you.


---
layout: docs
template: t-docs
title: Settings > CORE-FUNCTIONS
name: px-to-rem
collection: docs-settings
parent: core-functions
---
Settings > core-functions > PX-TO-REM
{% highlight scss %}
{% include haiticss/src/settings/core-functions/_px-to-rem.scss %}{% endhighlight %}


{% extends "layout.html" %} {% block page_title %} Do they need help completing tasks online? {% endblock %} {% block content %} Back Do they need help completing tasks online? Do they need help completing tasks online? Regularly Only new tasks Rarely or never {% endblock %}


PETSc interfaces to the following optional external software (installing packages) (manual pages):
- AMD - Approximate minimum degree orderings.
- BLAS and LAPACK
- CUSP - a C++ templated sparse matrix library for CUDA GPUs.
- Chaco - a graph partitioning package.
- ESSL - IBM's math library for fast sparse direct LU factorization.
- FFTW - Fastest Fourier Transform in the West, developed at MIT by Matteo Frigo and Steven G. Johnson.
- HDF5 - the data model, library, and file format for storing and managing data.
- Hypre - the LLNL preconditioner library.
- LUSOL - sparse LU factorization and solve portion of MINOS, Michael Saunders, Systems Optimization Laboratory, Stanford University.
- Mathematica,
- MATLAB,
- MUMPS - MUltifrontal Massively Parallel sparse direct Solver.
- ParMeTiS - parallel graph partitioner.
- Party - a graph partitioning package.
- PaStiX - a parallel LU and Cholesky solver package.
- PTScotch - a graph partitioning package.
- SPAI - for parallel sparse approximate inverse preconditioning.
- SPRNG - The Scalable Parallel Random Number Generators Library.
- Sundial/CVODE - the LLNL SUite of Nonlinear and DIfferential/ALgebraic equation Solvers.
- SuperLU and SuperLU_Dist - robust and efficient sequential and parallel direct sparse solves.
- Trilinos/ML - ML: Multilevel Preconditioning Package. Sandia's main multigrid preconditioning package.
- SuiteSparse, including KLU, UMFPACK, and CHOLMOD - sparse direct solvers, developed by Timothy A. Davis.
- ViennaCL - Linear algebra library providing matrix and vector operations using OpenMP, CUDA, and OpenCL.
PETSc contains modifications of routines from
- LINPACK (matrix factorization and solve; converted to C using f2c and then hand-optimized for small matrix sizes)
- MINPACK (sequential matrix coloring routines for finite difference Jacobian evaluations; converted to C using f2c)
- SPARSPAK (matrix reordering routines, converted to C using f2c, this is the PUBLIC DOMAIN version of SPARSPAK)
- libtfs (the scalable parallel direct solver created and written by Henry Tufo and Paul Fischer).
Instrumentation of PETSc
- PETSc can be instrumented using the TAU package [check installation instructions].
PETSc software is developed and maintained with
PETSc documentation has been generated using


Overview
Package
Class
Use
Tree
Deprecated
Index
Help
kool-parent 0.1.27 Reference
Prev
Next
Frames
No Frames
All Classes
Package org.davidmoten.kool
Class Summary
Class
Collector
Emitter
Indexed
Maybe
MaybeTester
Notification
Plugins
RetryWhenBuilder
RetryWhenBuilderMaybe
RetryWhenBuilderSingle
Single
SingleTester
Statistics
Stream
StreamIterable
StreamIterator
Tester
Overview
Package
Class
Use
Tree
Deprecated
Index
Help
kool-parent 0.1.27 Reference
Prev
Next
Frames
No Frames
All Classes


Address:
Request 1DGB
Explorer URL
Address
DigiID
None
Small logo with white box
Small logo with white circle
Small logo with white fit boarder
Small logo with no boarder
Large logo with light circles
Large logo with light squares
Larger logo with small dots
Radius:
Width:
Installation:
To install on your on web site
download digiQR.min.js
and put in same folder as your web site then use the bellow code in your page:
Code here:
GitHub Code
Donations Welcome:
DLExRXZ4oXnEWEpP6bNYG4urNLnDr4jJ2n


virtual universities, journeys through the human body, pop up cities, a five-part exploration of cyber threats, 80 foot executive presentations, sports hero documentaries, cinema spoofs, musical interludes, superhero social media campaigns, identity transformations, and just about anything else we’ve dreamed up for our clients.
Lorem ipsum dolor sit amet, consectetur adipisicing elit. Id nemo placeat odio officiis sequi voluptate, quod voluptates molestiae, accusantium, earum fuga dolore aspernatur. Odio placeat quas, earum dolores quae obcaecati.


This is a backend Api Designed to manage an online delivery system. The features include Product management,Order Management,User Management And Delivery Management.This is a mvp version without payement integration.
The System can incorporate three levels of users namely the siteadmin,deliverystaff and the common customer.Site admin is responsible for the management of addition updation and deletion of products,managing orders and assigning it to corresponding staff.The delivery staff can keep track of orders to be delivered and the one's already delivered.They hav the permission to update the status of an order after completion of a delivery.The common user can create an account, login to the site sort various products by their categories and place orders.the user can also view placed orders and history of previous orders.
There are four modules for the management of each functionality.


Take a colorful stroll on Gradient Lane 🚶
Oh hey there, thanks for stopping by. You came here looking for inspiration, thus I feel obliged to tell you that…you came to the right place!! We have a nicely curated collection of beautiful gradients on this page and also a list of some of the best resources for swatches all across the web. Have fun exploring!
Copied!
Copied!
Copied!
Copied!
Copied!
Copied!
Copied!
Copied!
Copied!
Copied!
Copied!
Copied!
Copied!
Copied!
Copied!


 Maybe you’re somewhere without access to the a network and/or the correct ports/protocols for security reasons. Maybe all network connections are down and you really need to transfer your changes to someone else. How do you go about that?
Of course, there is the git-bundle solution, but I feel it is probably more suited to large projects where you only need to sync changes about small parts of the code base, rather than the whole repo, and it involves creation of bundle files which I was not too happy about doing.
I therefore went instead on the route of creating a normal repo on my USB stick and using it as the transport mean. This involves creating a bare repo on the usb stick and adding the correct remote branches on machines either side of the transfer.
I’m working on a mac, so you’ll have to adapt the paths to your own situation.  All you need to do is to pull it from your second machine!
On machine B (Where you want to transfer the code to)
Set up a new repository to receive the code, add a remote branch from the stick and pull the changes as you would normally do
machineB$ cd /path/where/IWant/My/Files/ machineB$ git init machineB$ git remote add stick /Volumes/USB_STICK_NAME/desired_repo_path/ machineB$ git pull stick master
You now have transferred your code from MAchine A to Machine B, and you can work normally on this machine, committing as you normally would. Then, to transfer the changes back to machine A. Nothing more simple:
On machine B
machineB$ git push stick
On machine A
machineA$ git pull stick
From there, if you have set up a remote tracking branch on a network server that co-workers pull from of from which you checkout code for deployment, you can now do a simple
machineA$ git push
And you’re good!
comments
IvanDM Wed, 17 Nov 2010 - 23:26
I used to do this. But I had to share code between mac, and windows, and linux machines. So I had to use FAT32. Result? Soon I got corruptions all over the place. If you can, use a proper filesystem. Problem is: where is a PROPER filesystem that is shared across those OS?


Nodemailer SES transport is a wrapper around aws.SES from the aws-sdk package. SES transport is available from Nodemailer v3.1.0.
The SES API exposes two methods to send mail – SendEmail and SendRawEmail. While the first one is really easy to use and Nodemailer is not actualy needed, then it is also quite basic in features. For example you can’t use attachments with SendEmail. On the other hand SendRawEmail requires you build your own MIME formatted email message which is far from being easy. And this is where Nodemailer steps in – it gives you a simple to use API while supporting even really complex scenarios like embedded images or calendar events.
In addition to the simple API, Nodemailer also provides rate limiting for SES out of the box. SES can tolerate short spikes but you can’t really flush all your emails at once and expect these to be delivered. To overcome this you can set a rate limiting value and let Nodemailer handle everything – if too many messages are being delivered then Nodemailer buffers these until there is an opportunity to do the actual delivery.
To use SES transport, set a aws.SES object as the value for SES property in Nodemailer transport options. That’s it. You are responsible of initializing that object yourself as Nodemailer does not touch the AWS settings in any way.
Additional properties to use are the following:
If you use rate or connection limiting then you can also use helper methods to detect if the sending queue is full or not. This would help to avoid buffering up too many messages.
Listen for the ‘idle’ event to be notified if you can push more messages to the transporter. To explicitly check if there are free spots available use isIdle() method (see example #2).
When sending mail there’s also an additional message option for setting SendRawEmail options
The info argument for sendMail() callback includes the following properties:
1. Not allowed to send messages
2. aws-sdk is not found
You need to install the aws-sdk module separately, it is not bundled with Nodemailer.
let nodemailer = require('nodemailer');
let aws = require('aws-sdk');
// configure AWS SDK
aws.config.loadFromPath('config.json');
// create Nodemailer SES transporter
let transporter = nodemailer.createTransport({
SES: new aws.SES({
apiVersion: '2010-12-01'
})
});
// send some mail
transporter.sendMail({
from<EMAIL_ADDRESS>to<EMAIL_ADDRESS>subject: 'Message',
text: 'I hope this message gets sent!',
ses: { // optional extra arguments for SendRawEmail
Tags: [{
Name: 'tag name',
Value: 'tag value'
}]
}
}, (err, info) => {
console.log(info.envelope);
console.log(info.messageId);
});
let transporter = nodemailer.createTransport({
SES: new aws.SES({
apiVersion: '2010-12-01'
}),
sendingRate: 1 // max 1 messages/second
});
// Push next messages to Nodemailer
transporter.on('idle', () => {
while (transporter.isIdle()) {
transporter.sendMail(...);
}
});
Nodemailer SES transport requires ses:SendRawEmail role
{
"Statement": [
{
"Effect": "Allow",
"Action": "ses:SendRawEmail",
"Resource": "*"
}
]
}


The program pairs experienced Layer5 community members with community newcomers to ensure a smooth onboarding experience. There is a lot going in the Layer5 community. Projects and working groups move fast. MeshMates are committed to helping their mentees in identifying an area of the projects to engage within, working groups to join, growing their Cloud Native knowledge, and network of relationships. By connecting one-on-one, MeshMates will share tips on how to have the best community experience possible.
Meshtees are encouraged to get to know their MeshMate as soon as they are assigned (MeshMates and Mentees will be introduced in the Layer5 Slack). Help your MeshMate understand your current skills, ideal topics of learning, and areas of passion. Doing so will help them to point out various aspects of projects that you might find your first foothold.
Slack’s video chat or Google Hangouts are both available for your use as tools for getting to know one another. While getting acquainted and onboarding into the community, we suggest the following goals:
Get familiar with all of the projects - Spend time understanding each of the Layer5 initiatives through high level overviews available in the community drive and in discussion with your MeshMate.
Identify your area of interest - Use time with your MeshMate to familiarize with the architecture and technologies used in the projects. Inform your MeshMate of your current skills and what skills you would like to develop.
Run Meshery - Put on your user hat and walk-through all of Meshery’s features and functions as a user.
Build Meshery - Confirm that you have a usable development environment.
Contribute - Grab an open issue or suggest a new one.
The comfort and safety of Layer5 community members is our priority. You must agree to the Code of Conduct to participate in the Layer5 community, and any violations of the Code of Conduct will be taken seriously. To report any violations please fill out this incident form.


Sheikh Rashid shifted to home from hospital
by https://www.facebook.com/dunyanewsRAWALPINDI (Dunya News) – Federal Minister for Railways Sheikh Rashid Ahmed has on Monday been shifted to home from Holy Family Hospital after being cleared by doctors, Dunya News reported.
According to details, Sheikh Rashid suffered from chest pain while meeting people at Lal Haveli and was rushed to Rawalpindi Institute of Cardiology. The cardiologists told that the federal minister’s ECG was normal.
The doctors said Sheikh Rashid is suffering from high blood pressure and sugar levels which caused pain in his chest. He was moved to Holy Family Hospital afterwards and subsequently to his home.


PERSONAL INFORMATION MANAGER
Make Your Daily Activities Easy
->This personal information manager will include the ability to write notes to ourself, set up tasks to accomplish, store all our contacts, and make appointments.
->In this we’ll allow for multiple user accounts, so we’ll need all the requiste account management functions, including creating,updating and deleting accounts.
->When a user logs in they will start at a day at a glance screen, which will list those tasks and appointments for that current day


It's very easy to visualize data on a map or with charts when using Google Fusion Tables. All you need is 4 simple steps:
What kind of data do you want to visualize? Do you have a spreadsheet? Or some spatial data as shapefile or KML?
You can import Google Spreadsheets, CSV and KML directly into Fusion Tables. If you have another format, just convert your data.
If you have your spatial data in one table, and your information to visualize in another table, you can simply merge the tables into a new one.
If you finally have your data in one table available, you can start to visualize your data, e.g. using the Google Maps API or the Google Chart API.


EnvironmentVariableName()
Syntax
Result$ = EnvironmentVariableName()Description
Returns the name of the current environment variable currently examined with ExamineEnvironmentVariables() and NextEnvironmentVariable(). EnvironmentVariableValue() may be used to return its value.
Parameters
None.
Return value
The name of the current environment variable currently examined with ExamineEnvironmentVariables() and NextEnvironmentVariable().
See Also
ExamineEnvironmentVariables(), NextEnvironmentVariable(), EnvironmentVariableValue()
Supported OS
All


% styles.forEach( function ( file ) { %> <% }); %> <% scripts.forEach( function ( file ) { %> <% }); %>
| PC Optimization | Optimize your PCs Performance by clearing your Junk Files |
| Defragmentation | Defragment the Drives |
| Registry Cleaner | Clean your windows registry with a Registry Cleaner |
| Parental Control | User can Block/Unblock the websites |
| Data BackUp | User can have a Backup |
| Firewall | Safeguard your machine |
| Antivirus | Virus Scan |
| Internet | Router Settings can be accessed from here |
| Advanced | Router settings can be accessed from here |
| Network Details | Check your Wi-Fi Network Inforamtion |
| dbm Graph | Know your Wi-Fi Speed |
| Signal Strength | Check your Signal Strength |
| Channel Interface |
Check your channel connected to Wi-Fi |
| Network Usage | Examine your Network Usage better |
| Network Speed | Monitor your Network Speed |
| Scheduled Activities | Schedule all activities including Disk Defrag, Antivirus Scan, pc Optimization |


The scope processing code has been optimized.
Bug #545: An exception was thrown when an XTM <topicRef> URI didn't not contain a fragment ("#"). This has now been fixed.
Bug #533: The tm-sources.xml now produces better error messages for certain errors.
The full-text integration has been upgraded to use Lucene 1.2 final. The Lucene change log is available here.
Added net.ontopia.topicmaps.query.core.QueryResultIF.close() which lets query results release its underlying resources.
Added net.ontopia.topicmaps.query.utils.QueryUtils.getQueryProcessor(TopicMapIF), which makes it possible to get a query processor optimized for the given topic map.
RDBMSTopicMapReference.delete() now delegates to RDBMSTopicMapStore.delete(), which allows TopicMapIF instances to be deleted if they contain no data.
The syntax of the URI locator returned by RDBMSTopicMapStore.getBaseAddress() was wrong. This has now been fixed. The correct syntax is 'x-tm:rdbms:12345', where 12345 is the id of the topic map.
Added net.ontopia.topicmaps.impl.rdbms.RDBMSSingleTopicMapSource, which lets you reference individual RDBMS topic maps.
This release is almost purely a bugfix release. It corrects a bug in the test suite, as well as an important bug in the RDBMS backend. We recommend that RDBMS users upgrade. Other users need not bother.
The functionality has been extended/changed in the following ways:
The generation of topic map IDs in links is now improved. It no longer depends on the logic:context tag.
The getTopicMapById(Object txnuser, String topicmapId) method on NavigatorApplicationIF has been deprecated. It will eventually be removed.
The getTopicMapRefId method on NavigatorApplicationIF has been added.
There has been one API change; a new constructor for the URILocator class has been added: URILocator(File file).
The following bugs were fixed:
Bug #538: A weakness in EncryptionWriter, an internal class used only for building releases, caused the test suite to fail on Windows and on platforms where the default encoding was not ISO 8859-1. This class has now been replaced by one which does not have this problem.
Some unreported problems with the importInto method in XTMTopicMapReader and LTMTopicMapReader have been fixed.
The following bugs have been fixed:
Bug #540: The positions of the two parameters to lookup by source locator were reversed in queries.xml, which caused all such lookups to fail with PostgreSQL databases. Subject address lookups had the same problem and failed with all databases. This is a serious bug, and has been fixed in this release. Upgrades are recommended.
Bug #539: The developer's guide had some out-of-date code exaaples.
Previous versions shipped with a built-in license key that would expire 90 days after the version was built. In version 1.3.2 this is different. The software comes with no default license key, and will not run before it gets one. Read section 3.2 of the install guide to see how the software finds its license key.
Some new features have been added, as listed below. Note also that the interpretation of XTM documents has changed, as described in section 57.3.
If the topic map has a reifying topic with a description occurrence (using the Ontopia description PSI) that description is now displayed on the topic map start page.
The tolog plug-in now lets you specify inference rules.
The Omnigator now displays the source locators of topics at the bottom of the page.
The Omnigator now produces stable links to topics, by using the symbolic IDs from the source files instead of object IDs.
The Omnigator now displays its version number, build details, and expiry date on the welcome page.
The functionality has been extended/changed in the following ways:
The output:id tag has been added. This tag makes it possible for web applications to produce stable links. This is related to bug #515.
In addition, some reference diagrams have been added to the tag library documentation, to make it easier to see how to traverse topic map information using the tag libraries.
A number of bugs have also been fixed:
Bug #513: The output:treediagram tag did not use the user context filter when labelling nodes in the tree.
Bug #489: The tm:occurrences tag accepted illegal values in the type attribute.
As part of the fix to bug #523 the behaviour of the XTM importer with respect to entities has changed. In earlier versions, one could refer from tm.xtm to the topic foo in the external entity tm.ent using #foo, but now it is necessary to use URIs of the form tm.ent#foo. Relative URIs inside tm.ent will now be resolved relative to the URI of that entity, rather than relative to the URI of the document entity as before. We realize that this may break existing documents, but the XML Base specification is very clear on what the correct behaviour is in this case.
Other improvements are:
The OntopiaRuntimeException now provides more information, which leads to better error messages in a number of situations.
The XTMContentHandler has been optimized somewhat, resulting in faster XTM imports. The exact speed-up depends on the topic map in question, but on average imports seem to be about 15% faster.
The engine (and the rest of the OKS) has been upgraded to the new log4j 1.2 release. This should have no impact on users in any way.
There have also been a number of API changes:
The TopicMapBuilderIF interface has two new methods for creating topics, which allow a single topic type or a collection of topic types to be added to the topic directly.
The net.ontopia.topicmaps.entry package has been considerably reworked and expanded, making it much more powerful and usable than it was before.
The DefaultTopicMapSource class now has methods for adding and removing topic map references. The TopicMapReferenceIF has a number of new methods added to it, making it considerably more powerful than it was before. The same applies to TopicMapSourceIF. The StoreFactoryReference and StoreRegistry classes and the TopicMapRepositoryIF interface have been added.
The TopicStringifiers utility class now has a method that lets the user specify desired base name and variant name scope.
The following bugs were fixed:
Bug #524: In some cases subject indicator merges when importing from XTM would result in broken topic maps.
Bug #516: Empty xml:base attributes caused XTM loading to fail.
Bug #457: When importing XTM topic maps, merged-in topic maps would add their source locators to that of the master topic map, which was wrong, and caused problems with reification.
Bug #511: Using scope on an occurrence or association in LTM would give a parse error if an association followed directly after. This was solved by increasing lookahead in the parser.
Bug #523: relative URIs inside XML entities in XTM documents are now resolved relative to the URI of the entity.
Bug #533: Bad error message when entering file as path in tm-sources.xml.
Bug #530: Bad error message from LTM parser when syntax name in #MERGEMAP not quoted.
The only change in this version is that the command-line LuceneIndexer tool now supports the use of x-tm:rdbms URIs to refer to topic maps stored in the RDBMS backend. This means it can be used to index RDBMS topic maps.
In this release, the only change was a bug fix:
Bug #476: Association predicates where the same role type was used more than once gave wrong results.
The documentation of the player element type in OSL was extended somewhat. The only other change was a bug fix:
Bug #494: NullPointerException on undefined otherClasses.
Two new command-line utilities were added in this version: net.ontopia.topicmaps.cmdlineutils.rdbms.RDBMSImport and net.ontopia.topicmaps.cmdlineutils.rdbms.RDBMSExport. These allow users to import and export topic maps into and out of the RDBMS backend from the command-line.
A minor optimization of the lookup queries was made for the PostgreSQL RDBMS server.
Otherwise, the major change was the introduction of support for virtual collections. What this means is when calling say getTopics() on TopicMapIF the topics will only be loaded as needed. This ensures that the JVM does not run out on memory when methods that return large numbers of objects are called. This change fixed bugs 507 and 509.
Some new features have been added or changed:
The export plug-in can now generate OSL schemas from existing topic maps.
The merge plug-in no longer does name-based merging by default. The option now has to be turned on explicitly.
The following bug was fixed:
Handling of associations with empty (un-specified) roleType fixed. See bug 413.
The behaviour of one tag has changed:
The logic:if tag now treats non-existent variables as being false. This makes it much easier to use the if tag.
The following bugs were fixed:
In some cases equals comparisons done with logic:if would give incorrect results. Now fixed. See Bug #503
The following bugs were fixed:
Runtime license no longer expire after 24 hours. See bug 488.
Class loader license key problem fixed. See bug 484.
Compiling the OKS under JDK 1.4 caused problems with running it on 1.3. This is now fixed.
Security exceptions thrown by the getProperty() calls in applets are now caught. See bug 500.
New features:
The subject index now shows the class hierarchy structure.
The class hierarchy structure can also be displayed as an image with links.
A new default stylesheet has been introduced.
Two new plug-ins were added: the tolog query plug-in, and the OSL schema validator plug-in.
The following bugs were fixed:
Bug #354: Statistics printer didn't use user context.
Bug #399: The CSS stylesheets now uses relative fonts sizes.
Bug #427: The statistics plug-in incorrectly counted topic types with no names.
Bug #448: The statistics plug-in didn't sort occurrences by type correctly.
Bug #459: The statistics plug-in association structure summary failed when association types had no name.
Changes:
The Acme GIF encoder has been replaced by better JGME encoder.
The TreeDiagramTag now produces transparent GIFs.
Multiple values are now allowed for object ids in context tag (bug #330). The navigator test framework has been extended to support this.
"function" elements can now have return values. This can be specified using the "return" attribute. The attribute should contain the name of a context variable whose value is to be returned. See bug #336.
The following bugs were fixed:
Bug #458: framework:setcontext would throw a NullPointerException when there was no user object in the session.
Bug #455: logic:if would silently accept testing on undefined variables. It now throws an error in this case.
Bug #464: logic:foreach would throw a NullPointerException when there was no user object in the session.
Bug #353: The "logic:set" tag didn't take the user context into account when sorting.
Bug #363: It was not possible to override the default comparator.
Bug #449: Maximum list lengths can now be specified in the navigator configuration file.
Notable changes in this release are:
All Ontopia Knowledge Suite components now support Java2 version 1.4.
Memory consumption has been reduced by, on average, 30%.
Support for LTM version 1.2 has been added. This new version contains some changes that break backwards compatibility. A python script for updating LTM topic maps to the new version is included in the distribution (${basedir}/utils/ltmfix.py). Usage: python ltmfix.py <oldfile> <newfile>
Added support for the ".hytm" file suffix in net.ontopia.topicmaps.utils.ImportExportUtils, because ISO recently renamed its old HyTime-based topic maps syntax to HyTM. See bug 419.
Data URLs used in HyTM topic maps are now being resolved into inline occurrences on import. HyTM export map inline occurrences back into data URLs. Note that this only apply to data URLs with the text/plain content type. See bug 355.
TopicTreeBuilder has been made more robust.
The test suite has been upgraded to use JUnit version 3.7.
The ReificationUtils class has two new methods: getReifyingTopics and getReifiedObjects.
The AssociationBuilder class now has new methods for building ternary associations.
The OntopiaRuntimeException has a new method getCause, which replaces the now deprecated getException, in order to be more in line with JDK 1.4 exceptions.
The TopicMapBuilderIF has a new method makeAssociationRole, which can also set the player of the role.
The following bugs were fixed:
Bug #269: The developer guide did not include documentation of topic map builders and factories.
Bug #300: The ordering of topic map objects in XTM canonicalization in some cases caused object to have the same sort key. The canonicalization specification was updated (version 1.1) to guarantee consistent ordering of objects with different properties. The canonicalizer has been updated according to the new specificiation.
Bug #432: <topicRef> elements occurring inside <subjectIdentity> and referring to external topic maps didn't cause those topic maps to be loaded. They should since the XTM specification clearly states that they should.
Bug #435: Resolving relative URI locators sometimes failed.
Bug #439: Error messages produced by the LTM processor has been made more readable.
Bug #461: The test suites produced lots of namespace-prefix related errors. These errors are now being filtered out by default, since they are of no importance.
Bug #442: The documentation of the MergeUtils.shouldMerge method was inaccurate. This has now been cleared up.
Changes:
The Lucene integration can now work with instances of org.apache.lucene.store.Directory directly. This will for example let you to create and search indexes in-memory using the RAMDirectory class.
The default token stream analyzer is now org.apache.lucene.analysis.standard.StandardAnalyzer, replacing StopAnalyzer.
Token stream analyzers can now be configured for use with the Lucene fulltext engine. This will let you plug your own analyzers. See the classes LuceneIndexer and LuceneSearcher for more information.
The following bugs have been fixed:
Bug #198: The IndexerIF.delete() method has been added. It lets you delete a fulltext index.
Bug #436: The fulltext plug-in didn't take the user context into account when displaying topic names.
Bug #437: The fulltext plug-in didn't process requests with extended characters properly.
Bug #440: The fulltext plug-in displayed long traceback when invalid queries was issued.
The following bugs have been fixed:
Bug #387: Adding objects that had been deleted earlier caused some of the object values to not be included.
Bug #317: Big imports ran out of memory.
The main change in the navigator in this version is that we now bundle it with Tomcat 4.0, something that caused us to upgrade certain parts of the code. In addition we have added some tags, and fixed a number of bugs.
A number of changes were made in the navigator framework itself:
The ontojsp JSP execution environment has been updated to support JSP 1.2.
The web application and tag library descriptors were updated to conform to the Servlets 2.3 and JSP 1.2 specifications.
The <framework:setcontext> and <framework:getcontext> tags were added.
The methods getModule and getRootNode in net.ontopia.topicmaps.nav2.core.FunctionIF were deprecated.
The following bugs were fixed in the 1.2.5 version of the Navigator Framework:
Bug #405: fixing the behaviour of the <tm:superclasses> and <tm:subclasses> tags.
Bug #408: the sequence-first and sequence-last variables were not set correctly by the <logic:foreach> tag.
Bug #376: order of roles within each association in a list of associations was inconsistent.
Bug #238: fixed in September 2001, now officially closed.
In addition, some bugs were also fixed in the Omnigator:
Bug #376: in n-ary associations, topics playing the same role as the current topic were not displayed.
Bug #407: associations with no type caused page display to crash.
Bug #304: order of roles within each association in a list of associations was inconsistent.
Bug #406: binary associations where the same topic plays both roles were displayed as empty.
There were few significant changes in the engine in this version.
Added the getSubclasses(class, level) and getSuperclasses(class, level) methods on net.ontopia.topicmaps.utils.TypeHierarchyUtils.
Added the getBaseAddress and setBaseAddress methods on the net.ontopia.topicmaps.entry.AbstractPathTopicMapSource class.
Three bugs were fixed in this release:
Bug #300: in some cases canonicalization of topic maps would give topics the same sort keys, thus giving random ordering of some topics.
Bug #410: when importing LTM files which had a topic with the sort name PSI and when that topic itself had a sort name the LTM parser would produce bad topic map object structures.
Bug #397: ISO exporter would fail when exporting association roles with no player.
The following bugs have been fixed:
Bug #378: Fulltext testsuite failed on default install (Windows only)
Bug #390: The Ontopia Full-text Integration - A Developer's Guide document has been updated to include information about the RDBMS URL scheme.
The following public class has been added::
RDBMSTopicMapReader
The following bug has been fixed:
Bug #390: The RDBMS Backend Connector - A Developer's Guide has been updated to include information about the RDBMS URL scheme.
This release has seen a number of minor improvements in the navigator framework. The changes in the tag libraries are:
The <output:treediagram> tag no longer uses Batik, but instead uses an open source GIF encoder. This makes the distribution a lot smaller.
The <tm:names> tag now rejects duplicate name objects.
In addition, the navigator developer's guide has been extended with more detailed information on how to use the <tm:lookup> tag.
This release was primarily made to satisfy customer requests for functionality in the full-text integration. Changes in the engine are limited to a few new method, and a minor extension to the engine developer's guide.
The following methods has been added:
net.ontopia.topicmaps.utils.TopicTreeRendrer.renderImage()
net.ontopia.topicmaps.utils.ImportExportUtils.getReader(String propfile, String filename_or_url)
net.ontopia.topicmaps.utils.ImportExportUtils.getReader(Map properties, String filename_or_url)
The following features has been added:
The LuceneIndexer command line tool can now index topic maps via the RDBMS Backend Connector. Such topic maps can be referenced using URLs of the following type "x-tm:rdbms:<topicmapid>", e.g. "x-tm:rdbms:5001".
The LuceneIndexer now accepts the --props=propfile option, which references the topic map store properties file.
The following constructors has been added - all to make it possible to pass topic map store properties as a Map instance:
RDBMSTopicMapStore(Map properties)
RDBMSTopicMapStore(Map properties, long topicmap_id)
RDBMSTopicMapSource(Map properties)
This release adds some new tags, and fixes a large number of bugs. The changes in the tag libraries are:
The <tm:topics> tag can now have other tags as content.
The <tm:lookup> tag has two new attributes: basename and variant.
The <output:name> tag has a new attribute 'stringifier', which can be used to control the rendering of names.
The <logic:if> tag has a new attribute 'sizeEquals', which can be used to test the size of a collection.
The following bugs were fixed in the Navigator Framework in this release:
Bug #371: <tm:lookup> does not work with relative URIs.
Bug #369: <logic:foreach> does not set up context correctly.
The following bugs were fixed in the Omnigator in this release:
The following method has been added:
net.ontopia.topicmaps.utils.ClassInstanceUtils.resolveAssociations()
One old bug has been fixed:
Bug #67: Class-instance associations not recognized
The following features has been added:
Support for JDBC batch writing. This option boosts performance with large transactions and in environments where network lag is an issue, since the number of network requests needed is significantly lower and the database may provide optimizations for performing lots of similar database modifications in batches.
JDBC Connection pooling. Note that this features requires the JDBC 2.0 Optional Package API to be installed. See the requirements section in the installation guide for more information.
Ability to disable conforming queries via configuration property, i.e. no longer guaranteeing that database query results matches changes in the current transaction. In this case there may be outstanding transaction changes that have not been written to the database to the time the query is issued. Be careful when disabling conforming queries.
Subject identity lookup in the database can be disabled via a configuration property. Warning: This option should only be used when it is known that topic map objects in the database with requested identities does not exist.
Changes in the database schema:
The following changes were done in the database schema because of the column name 'value' sometimes conflicting with the 'VALUE' SQL keyword. If you have database instances using the old database schema you need to perform the following changes the database schema:
Rename TM_BASE_NAME.value to TM_BASE_NAME.content
Rename TM_VARIANT_NAME.value to TM_VARIANT_NAME.content
Rename TM_OCCURRENCE.value to TM_OCCURRENCE.content
This release adds some new tags, and fixes a large number of bugs. The changes in the tag libraries are:
The new <tm:sourceLocators> tag for retrieving the source locators of a topic map object has been added.
The new <tm:reified> tag for retrieving the object reified by a topic has been added.
The <tm:filter> tag has a new attribute 'is', which can be used to filter objects according to whether they are topics, base names, occurrences, associations, or something else.
The <tm:filter> tag can now use instances of DeciderIF and not just NavigatorDeciderIF.
The 'sequence-index' variable set by the <logic:foreach> tag now begins with 1, rather than 0, as it used to.
The following bugs were fixed in the Navigator Framework in this release:
Bug #334: <logic:call> does not work inside modules.
Bug #335: <logic:externalFunction> should not call the function, just register it.
Bug #339: <output:name> and <tm:name> do not support variant name selection.
Bug #342: Navigator framework should support more than one content-type in the same web application.
Bug #350: Plug-ins are hardcoded to 'omnigator' directory.
The following bugs were fixed in the Omnigator in this release:
Bug #320: Reified topic map objects not displyed on topic.
Bug #349: Make Omnigator display better in Netscape 4.
The following method has been added:
net.ontopia.topicmaps.core.TopicMapTransactionIF.getBuilder()
Added the <framework:response> JSP tag, which sets response headers according to its attribute values or the application defaults.
Version 1.2 of the Ontopia Navigator Framework and the Ontopia Omnigator is a complete rewrite of the entire navigator framework, and also of the Omnigator, which has now been implemented using the new framework. The old navigator is still included in the distribution, but the documentation has been taken out.
We have replaced the old tag libraries with a completely new set of tag libraries, which are designed according to different principles. We think that the new tag libraries are enormously much easier to learn than the previous ones, and that they are also much more flexible. The Omnigator has been completely re-implemented (making the current version the fifth implementation from scratch) using the new tag libraries.
Since the entire navigator package has been entirely replaced by a new package there is no list of changes. Note that we expect changes to the navigator from this point on to be backwards-compatible, except where current features are marked as experimental in the documentation.
There were few changes in this new release. Some new functionality has been added, and some problems have been fixed, but in general very little has happened with the engine.
Two improvements have been made:
when importing XTM documents, unknown elements in the XTM namespace are now warned about, and
MergeUtils did not copy source locators from source objects to target objects, but this is now fixed.
Four new classes have been added:
net.ontopia.topicmaps.utils.ImportExportUtils,
net.ontopia.topicmaps.utils.ReificationUtils,
net.ontopia.topicmaps.utils.AssociationBuilder, and
net.ontopia.topicmaps.utils.DuplicateSuppressionUtils.
Only one bugs were fixed in this release:
Bug #259; misspelling the name of the topicMap element causes NullPointerExceptions.
Bug #305; topic map ID sometimes set to file URI on export.
Bug #308; LTM reader did not handle duplicate subject indicators.
Reviewed the classes in package nav.utils.comparators; BaseNameComparator deprecated, NameComparator takes sort variant into account if available.
nav.context.UserFilterContextStore extended to also store variant name scoping themes (basides base name scope)
Occurrence.toString() now prints contents of inline occurrences.
CollectionUtils.getRandom() now delivers a really random entry.
Four bugs have been fixed:
Bug #237 fixed; export of empty and null strings generally improved,
Bug #241 fixed; XTMContentHandler and internal class ContentHandler of XMLConfigSource now use qualified name of element instead of local name in methods startElement and endElement,
Bug #244 fixed; subject indicator references from topics to reified topic map objects are no longer broken on export to XTM format, and
Bug #245 fixed; the ISO export can now handle the case where the PSI for display or sort name appears as a source locator instead of as a subject indicator.
A new plug-in has been added: the "LTM add" plug-in, which lets you add content to already loaded topic maps using LTM syntax.
A part of the documentation relating to how connect the navigator to the RDBMS backend was updated.
The LTMTopicMapReader class now also implements the TopicMapImporterIF interface.
The NameGrabber class can now grab names appearing in a specific scope defined by a collection of topics.
Some problems with the test suite, both on Windows and generally, have been fixed.
Two bugs have been fixed:
The major change in this release is that we have upgraded the bundled version of tomcat, closing a security hole. Other than that the main changes are bug fixes.
The tomcat version bundled with the navigator was upgraded from version 3.2.1 to 3.2.3. This makes the navigator start much faster, and also closes a serious security hole in tomcat.
Bug #225 (Plug-ins don't work in Netscape 4.x) has been fixed.
Bug #226 (Statistics table display problems in Netscape 4.x) has been fixed.
The ConfigReader class has been improved to make it much more robust in cases where files are missing, configuration settings are missing or configuration files are screwed up.
Only very minor changes have been made to the engine. These are:
Bug #219 (Obscure merging bug) has been fixed.
Bug #222 (Problem with null role players in merging) has been fixed.
The XMLConfigSource class was made more robust. It now gives much better error messages when problems occur.
Some new test cases have been added. Some of these test for the fixed bugs, others test new things.
Since version 1.1 the code of the Navigator Framework has been further improved through optimizations, some internal refactoring of the code, and also a number of bug fixes. The result is a version of the framework that is decidedly more mature and performs better. In particular, loading topic maps is now substantially faster than in previous versions.
In addition to the improvements to the framework, the Omnigator has been revisited and its user interface further improved. Some bugs have also been fixed in the Omnigator, making it able to handle even more topic maps.
This release also contains substantially improved and extended documentation compared to the 1.0.x releases.
The main improvements, however, fall in the category of extended functionality. The following are the main extensions:
The Navigator framework has been extended to support a user context filter, which users can use to apply scope filtering to topic maps, in order to filter out unnecessary information or, for example, switch the language they are navigating in. The user context filter is described in more detail in The Ontopia Omnigator User Guide.
The Navigator has been extended with the concept of plug-ins, which are encapsulated functionality that can be dropped into Navigator applications. This concept is described in the Ontopia Navigator Plug-ins Developer's Guide.
The Navigator now has native support for the textual LTM topic map format (described in a separate technology note), which means that LTM files can now be loaded directly into Navigator applications.
The log4j package used by the engine to provide logging of actions has been upgraded from version 1.0.4 to version 1.1.3, which has given better performance in some cases.
The application.xml file has been extended to allow users to specify the default model, view, and skin. It is also possible to extend the lists of models and views. Skins are now found by scanning a specified directory for CSS stylesheets.
The superTypes tag now has an excludeTypes argument in the args attribute, which can be used to keep the types of the current topic out of the list of supertypes.
The following new tags have been added:
DescriptionOccurrencesTag
FacetValueTypesTag
IndexScopesTag
ResourceFacetValuesTag
SubjectIndicatorsParentTopicsTag
See The Ontopia Navigator Tag Library Reference for more information on these tags.
In general, the changes to the Topic Map Engine itself have not been very substantial. The main changes have been made externally, such as the addition of an RDBMS backend, modifications to the Navigator, integration of the Fulltext Search capability, and so on.
A number of optimizations have been done, however, resulting in markedly improved performance for some operations, like importing XML topic maps. A number of minor bugs have also been fixed, and XML import is now more robust, and also gives better error messages than before.
The URILocator class has been rewritten from scratch. The original was based on the java.net.URL, which meant that it couldn't handle non-standard URI protocols or characters in URIs that were not in the platform default character set. It was also too slow. The new implementation solves all these problems.
The engine now has native support for the textual LTM topic map format (described in a separate technology note), which means that LTM files can now be imported directly into the object model. This support is found in the net.ontopia.topicmaps.utils.ltm package.
The log4j package used by the engine to provide logging of actions has been upgraded from version 1.0.4 to version 1.1.3, which has given better performance in some cases.
The test suite has been extended with about 150 new test cases, making it substantially more comprehensive.
The main API changes have been in the net.ontopia.topicmaps.utils package, where the changes listed below have been made. Some methods have also been deprecated and added; see the javadoc for these. Generally the API changes have been quite limited.
Added the NameGrabber class in the package. This is a generally useful class used to pick out the in some sense most appropriate name from a topic.
Added the TopicCharacteristicsGrabbers class as a generalization of DisplayNameGrabber. DisplayNameGrabber was deprecated accordingly.
Added the UnconstrainedScopeDecider class as an easy way to make other scope deciders accept all objects in the unconstrained scope.


bio-info, SVM and Graph-kernels
22 May 2015Introduction
This page is the practical session of the "Support Vector Machines" module taught by Chloé-Agathe Azencott.
Material
The practical session is done using R. For a quick tutorial, follow this link.
Practical Session
Necessary support:
Part A: Linear dataset.
A.1/A.2) Visualization of the first dataset:
load('linear1.RData')
3 new variables are in the environment now (type ls()
to check):
- linear1.train : a matrix of size n1x3 (first column is x1, second column is x2 and third column is the output y).
- linear1.test.input : a matrix of size n2 x 2 (same as the train but without the output y).
- linear1.data : the combined dataset (for visualization).
Then visualize the dataset:
require( 'ggplot2' )
qplot( data=linear1.data, x.1, x.2, colour=factor(y),
shape=factor(train) )
Question 1: How can you characterise this dataset ?
Given what we learned during the lecture, we train a linear SVM on the training set which will be our predictor for the testing set.
A.3/A.4/A.5) Training the SVM:
### A.3) Train a linear SVM
require( 'kernlab' )
linear1.svm <- ksvm( y ~ ., data=linear1.train, type='C-svc',
kernel='vanilladot',
C=100, scale=c() )
### A.4) Plot the model
plot( linear1.svm, data=linear1.train )
### A.5) Adding points of test on the graph
points( linear1.test.input[ sample.int(nrow(linear1.test.input),10), ], pch=4 )
Question 2: What are the black points in the figure ?
A.6/A.7 Testing on another dataset:
### A.6) Prediction
linear1.prediction <- predict( linear1.svm, linear1.test.input )
### A.7) Look at accuracy
load('linear1Sol.RData')
# contains linear1.test.output
print(paste0('Accuracy: ', floor(100*sum( linear1.prediction == linear1.test.output )/length(linear1.test.output)), '%'))
Let's consider a dataset a bit more complex:
A.9 to A.14) This is the exact same thing as the first part except that the dataset is non-separable.
Question 3: Is the accuracy a sufficient method to assess the performance of a model?
Let's discuss a few ways to improve the assessment of the performance:
A.15) Separate positive and negative examples :
### A.15) A confusion matrix gives more information than just accuracy
print('Confusion Matrix: ');print(table( linear2.prediction, linear2.test.output, dnn= c("prediction","reality") ))
A.16) ROC Curves (See wikipedia):
linear2.prediction.score <- predict( linear2.svm, linear2.test.input, type='decision' )
require( 'ROCR' )
## ROC
linear2.roc.curve <- performance( prediction( linear2.prediction.score, linear2.test.output ), measure='tpr', x.measure='fpr' )
plot( linear2.roc.curve )
Part B: Non-Linear dataset.
B.1/B.2/B.3) Trying linear SVM on a dataset where it is not appropriate.
Let's try a different kernel
B.4) RBF Kernel:
nonlinear.svm <- ksvm( y ~ ., data=nonlinear.train, type='C-svc',
kernel='rbf', kpar=list(sigma=1),
C=100, scale=c() )
plot( nonlinear.svm, data=nonlinear.train )
Question 4: Recall what is the parameter C
in the svm. In the following we will see what happens when we vary C
.
B.5) Impact of C
require('manipulate')
manipulate( plot( ksvm( y ~ ., data=nonlinear.train, type='C-svc',
kernel=k, C=2^c.exponent, scale=c() ),
data=nonlinear.train ),
c.exponent=slider(-10,10),
k=picker('Gaussian'='rbfdot', 'Linear'='vanilladot',
'Hyperbolic'='tanhdot','Spline'='splinedot',
'Laplacian'='laplacedot') )
B.6) Visualization of the impact of C
on the prediction accuracy (Bias-Variance Tradeoff):
### B.6) Bias-Variance Tradeoff
BiasVarianceTradeoff <- function( dataset, cross=10, c.seq=2^seq(-10, 10), ... ) {
err <- sapply( c.seq, function( c )
{
cross( ksvm( y ~ ., data=dataset, C=c, cross=cross, ...) )
})
return(data.frame( c=c.seq, error=err ))
}
qplot( c, error, data=BiasVarianceTradeoff( nonlinear.train, type='C-svc', kernel='rbfdot' ), geom='line', log='x' )
Question 5: How to choose C
?
Part C: Acute lymphoblastic leukemia dataset.
In this part, we work on a real public dataset of Acute lymphoblastic leukemia (ALL) patients.
C.1) We are interested in classifying leukemia patients into two classes: B-cell ALL vs T-cell ALL because this classification can have an impact on the patient's prognosis or its response to a given treatment.
C.2) When we add supplementary clinical information, we have more than 2 classes (B1, B2,...).
Question 6: How can you derive from what you learned a SVM classifier that can predict more than 2 classes?


Feedback Your feedback will help us to improve this service.
Greenwood High School
URN: 123456
Cavendish Road, Bournemouth, Dorset, BH1 1QYDetails
What parents say
I would recommend this school
Yes: 75%
My child is happy at this school
Strongly agree: 38%
Agree: 45%
Disagree: 8%
Strongly disagree: 8%
Don't know: 1%
Based on the responses of 53 parents given on 28 March 2018. Read more from parents.
Pupils
- Age Range 11 - 16
- Gender Mixed
- Number of pupils 600
- School capacity 630
Details
- Principal Mrs Angela Richardson
- Boarding provision No
- Type Academy
- Religious character Does Not Apply
- Local authority Dorset
- Region South West England
- Telephone 01202 578 080
- Website http://www.greenwoodhigh.co.uk/
Elsewhere on the web
Give feedback to Ofsted on your child's school
Survey for Greenwood High School open until midday on 17 May 2019.
Give feedback to Ofsted on your child's school
Survey for Greenwood High School open until midday on 17 May 2019.


No Matches


The
REXUS/BEXUS programme is realised under a bilateral Agency Agreement between the German Aerospace Center (DLR) and the Swedish National Space Board (SNSB). The Swedish share of the payload has been made available to students from other European countries through a collaboration with the European Space Agency (ESA). EuroLaunch, a cooperation between the Esrange Space Center of SSC and the Mobile Rocket Base (MORABA) of DLR, is responsible for the campaign management and operations of the launch vehicles. Experts from DLR, SSC, ZARM and ESA provide technical support to the student teams throughout the project. REXUS and BEXUS are launched from SSC, Esrange Space Center in northern Sweden.