The dialog is divided into five areas (the lower three areas are only active
when elliptic curve keys are generated):
Choice of algorithm:
For RSA and DSA keys, the length of
the key must be specified (in bits). The RSA modulus n (n is the
product of two approximately equal-sized prime numbers) must be between 301 and
8192 bits long. Every integer in between is valid and is accepted if
entered. Bit lengths 512, 768, 1024 and 2048 are already pre-defined and can be
selected with the mouse.
The DSA prime number p - through which
essentially the DSA key is determined - must be between 301 and 8192 bits long, in addition its length must be divisible by 64. The bit lengths 512, 768, 1024 and 2048 are already pre-defined and can be
selected with the mouse.
For elliptic curves, seven options are
provided. The curves are selected by choosing among a set of "parameter
identifiers" (also known as "curve identifiers"). Every parameter identifier is
of the form primeXXXvY, where XXX stands for the bit length of prime number p
and Y distinguishes different curves for which p has the same bit length. (The
elliptic curve is defined through Z[p]. See also Elliptic Curves
CT Book, section entitled Elliptic Curves in Cryptography.)
User information:
There are fields in which to enter user-relevant data by means of which it is
possible to distinguish the different keys.
Entries in the fields Lastname, First name, PIN and
PIN verification are mandatory. An entry in Key identifier is
optional and enables you to create several keys under your own name. When
entering the last name, first name and key identifier, no special characters
(for example, \ / : * ? " < > | ) may be used; if they are, an
appropriate error message will be displayed.
Domain parameters:
In the Domain Parameter box at the bottom of the window, the parameters
for the currently selected curve identifier are displayed. The Elliptic Curves
script, section entitled Elliptic Curves in Cryptography, explains what
is meant by domain parameters.
Base for presentation of numbers: The choices available are octal, decimal and hexadecimal (see
ASCII Table).
Display generated key pair:
This field allows you to decide whether you wish to see the key
pair generated for elliptic curves or
not. If you choose to have the key pair displayed, a new dialog,
Display public and private key for elliptic curves, is opened. Here you
can continue generating pseudorandom numbers until one of the key pairs
generated "pleases you" and you are happy to keep it.
Every key pair generated and any additional relevant data are stored under a key
identifier.


I enjoy building products, problem solving and learning more about how the world works.
Managed and launched digital products on Shopee in South East Asean Countries.
Developed and designed APIs and software to power the machine learning models as well as to enable clients to interact with and obtain insights from our models.
Designed and developed internal tools to automate and speed up internal operational work and display insights for the operations and sales teams.
Maintained the platform and developed new features to improve the web application with Ruby on Rails.
Designed and developed an automated testing and deployment pipeline with CircleCI, Gitlab, Docker and Fastlane.
Part of the research team to build tools to reduce devlopment time and provide insights to the main team to better engineer their race car.
Developed a tire data visualization tool for the team with custom features, saving the team $3000 annually and weeks of development time with MATLAB and Python.
Built a damper tuning tool for the team to tune the suspension with a reverse quarter car model with road profile, cutting cost and development time by weeks with MATLAB, Python and Arduino using C.
A ready to use tool for 3-D printing hobbist to automate the detection of print errors.
Designed and developed the backend and REST API with Python, Django, Celery, Redis and NGINX.
Built a ready-to-use tool prototype with a Raspberry pi using Python and OpenCV.
A web tool for NUS students to sync files on the school platform to any cloud service of their choice (Gdrive, oneDrive etc).
Led a team to build a cloud service that syncs students’ school files to any cloud storage service of their choice, gaining 300 users in 4 weeks.
Developed the backend and REST API with Python, Django, Celery, Redis and NGINX.
Project Code @GithubA web tool to allow students in NUS to rate NUS professors anonymously.
Developed the backend and REST API with Python, Flask and NGINX.
Project Code @GithubA pipelined Processor based on ARM Architecture using verilog on an FPGA
A simple bash shell that can perform ls, grep, cat, piping and background tasks using C with multiprocessing and signals.
National University of Singapore Kent Ridge Scholarship
University Scholars Programme
Design Centric Program
Varsity Athlete, represented National University of Singapore
President, National University of Singapore Entrepreneurship Society
Part Of NUS Overseas College Program
Avid reader of business strategy, amateur stock trader, competitive fencer, frequent backpacker (been to over 20 countries).


Public Utilities Commission denies Hawaii Electric Light rate increase request | Honolulu Star-Advertiser
A small planned increase to electrical rates on Hawaii island was denied Wednesday by the state Public Utilities Commission.
Hawaii Electric Light Co., a subsidiary of Hawaiian Electric Industries Inc., applied in December for a 3.4% base rate increase that would have generated an additional $13.4 million for the company.
As part of PUC proceedings over the regulated company’s request, HELCO and the state Consumer Advocate settled some issues but still disagreed on a deserved rate adjustment.
Under the partial settlement, HELCO advocated for an interim rate increase that would generate an additional $2.8 million in revenue. The Consumer Advocate pushed for a $2.9 million decrease.
The PUC ruled that no change is warranted on an interim basis.
“The commission finds that HELCO has not met its burden of proving that it is probably entitled to an increase in revenues on an interim basis that is in addition to current effective revenues,” the commission said in its order.
It’s still possible that a final decision could deviate from the interim decision after an evidentiary hearing scheduled for next month.


Cheat Sheet: Iterating over Arrays in Ruby and JavaScript
August 4, 2015
This “cheat sheet,” which summarizes the most commonly used methods that Ruby provides to iterate through data collections and their JavaScript equivalents, was made in collaboration with Julia Graber. Please note that most (but not all) of the Ruby methods belong to the Enumerable module, and that the JavaScript methods only work for arrays—although some JavaScript libraries will extend their functionality to object literals. Ruby code snippets are provided first, followed by the JavaScript versions. One particularly salient difference between them is the requirement for explicit return
s in JavaScript.
#each and .forEach()
#each
calls the given block once for each element, passing that element in as a parameter. The JavaScript equivalent is .forEach()
.
arr = [1, 2, 3, 4, 5]
# Ruby
arr.each { |i| puts i }
// JavaScript
arr.forEach(function(i) { console.log(i) })
/* outputs sequentially 1, 2, 3, 4, 5 */
#map and .map()
#map
creates a new array using the values returned by calling the block for each element. The JavaScript equivalent is .map()
.
arr = [1, 2, 3, 4, 5]
# Ruby
arr.map { |i| i * 2 }
// JavaScript
arr.map(function(i) { return i * 2 })
/* [2, 4, 6, 8, 10] */
#select and .filter()
#select
(or #find_all
) returns a new array that contains all values that pass as true in the given block. The JavaScript equivalent is .filter()
.
arr = [1, 2, 3, 4, 5]
# Ruby
arr.select { |i| i % 2 == 0 }
// JavaScript
arr.filter(function(i) { return i % 2 == 0 })
/* [2, 4] */
#inject and .reduce()
#inject
(or #reduce
) combines all elements in an array by passing each element into a block. The accumulator is the first parameter specified within the pipes of the code block and can optionally be given a starting value by including an argument with the #inject
method. The iterated variable is the second parameter included in the code block. The JavaScript equivalent is .reduce()
. Note that the optional starting value is placed as the second parameter of the JavaScript .reduce()
method.
arr = [1, 2, 3, 4, 5]
# Ruby
arr.inject(0) { |acc, i| acc += i }
// JavaScript
arr.reduce(function(acc, i) { return acc += i }, 0)
/* 15 */
#all? and .every()
#all?
passes each element to the block, and will return true
if the block never returns false
or nil
. The JavaScript equivalent is .every()
.
arr = [1, 2, 3, 4, 5]
# Ruby
arr.all? { |i| i > 1 }
// JavaScript
arr.every(function(i) { return i > 1 })
/* false */
#any? and .some()
#any?
passes each element to the block, and will returns true
as long as any one element evaluates as true. The JavaScript equivalent is .some()
, which can also be used to mimic the behavior of Ruby’s include?
method.
arr = [1, 2, 3, 4, 5]
# Ruby
arr.any? { |i| i > 4 }
// JavaScript
arr.some(function(i) { return i > 4 })
/* true */
Coda
Comparing the pairs of code snippets above reveal a somewhat surprising similarity between the Ruby and JavaScript versions of these powerful iteration options, something which I feel is usually obscured by JavaScript’s syntax.
For more information on these and many other helpful methods for data collections, the reader is referred to RubyDocs and Mozilla’s JavaScript Reference.


Month: {{ date.month }}.{{ date.year }}
Model: {{ model | json }}
From: {{ fromDate | json }}
To: {{ toDate | json }}


{% comment %} This form template is meant to be used with the "include" template tag. {% endcomment %}
| {% include "annotations/form_annotation_area_one_field.html" with field=form.min_x %} | {% include "annotations/form_annotation_area_one_field.html" with field=form.max_x %} |
| {% include "annotations/form_annotation_area_one_field.html" with field=form.min_y %} | {% include "annotations/form_annotation_area_one_field.html" with field=form.max_y %} |


Version Control, Git, And GitHub
September 20th, 2014
Version control keeps track of the changes you make to a file. There are many benefits to using version control. One of the main benefits is that it allows you to revert back to an earlier version of your file if something goes wrong while you are making changes. By flipping through the different versions you can see how your file has progressed over time. Version control becomes more important when working on the same files with collaborators because it allows all of the collaborators to work on the same file at the same time without overwriting each other's code.
Git is a version control system. It keeps track of all of the changes you make to a file by using the "commit" comand. Every time you execute a commit, you create a new version of your file with the added changes. Git only allows you to execute the commit command when new changes have been added to the file. Git tracks who made the changes to the file, what changes were made, and when the changes were made.
GitHub is a Git repository web-based hosting service which offers all of the distributed revision control and source code management functionality of Git as well as adding own features. There are several benefits for using GitHub to store your code.One benefit is that it allows you to access your code from any computer as long as you have an internet connection. Since you can access the code from any computer, it makes it easy to share your code with other programmers so that you can work as a team on a project. GitHub also makes it easy to keep the changes synchronized between all of the collaborators so that everyone is working from the same version of the code.
GitHub has also been described as the new resume. It allows devleopers to showcase their code as well as their involvment in the GitHub community. It is important to store your code on GitHub so that future potential employers can see your work. An active GitHub account may be the difference between whether or not you get the job you are applying for.


Find out how much State Pension you may get, how to get more and when you can claim it.
You’ll be sent to GOV.UK Verify to sign in. If you have not used GOV.UK Verify before, it will take you about 10 minutes to get set up.


Netcat
tags: linuxI had occasion recently to need an entry in my ssh config such that connections to a certain host would be proxied through another connection. Several sources suggested the following snippet:
In my situation, I wanted the connection to be proxied through an ssh tunnel that I already had set up in another part of the config. So my entry looked like:
Try as I might however, I just could not get it to work, always receiving the following message:
After some head scratching, checking and double-checking that I had set up the proxy tunnel correctly, I finally figured out that it was because I had GNU netcat installed rather than BSD netcat. Apparently, most of the people in the internet use BSD netcat :)
Worse, -x
is a valid option in both netcats but does completely different things depending on which you use; hence the less-than-specific-but-technically-correct error message.
After that revalation, I thought it was worth capturing the commonalities and differences between the options taken by the netcats.
Common options
-
-h
Prints out nc help.
-
-i interval
Specifies a delay time interval between lines of text sent and received. Also causes a delay time between connections to multiple ports.
-
-l
Used to specify that nc should listen for an incoming connection rather than initiate a connection to a remote host. It is an error to use this option in conjunction with the -p, -s, or -z options. Additionally, any timeouts specified with the -w option are ignored.
-
-n
Do not do any DNS or service lookups on any specified addresses, hostnames or ports.
-
-p source_port
Specifies the source port nc should use, subject to privilege restrictions and availability.
-
-r
Specifies that source and/or destination ports should be chosen randomly instead of sequentially within a range or in the order that the system assigns them.
-
-s source
Specifies the IP of the interface which is used to send the packets. For UNIX-domain datagram sockets, specifies the local temporary socket file to create and use so that datagrams can be received. It is an error to use this option in conjunction with the -l option.
-
-t
in BSD Netcat,-T
in GNU NetcatCauses nc to send RFC 854 DON’T and WON’T responses to RFC 854 DO and WILL requests. This makes it possible to use nc to script telnet sessions.
-
-u
Use UDP instead of the default option of TCP. For UNIX-domain sockets, use a datagram socket instead of a stream socket. If a UNIX-domain socket is used, a temporary receiving socket is created in /tmp unless the -s flag is given.
-
-v
Have nc give more verbose output.
-
-w timeout
Connections which cannot be established or are idle timeout after timeout seconds. The -w flag has no effect on the -l option, i.e. nc will listen forever for a connection, with or without the -w flag. The default is no timeout.
-
-z
Specifies that nc should just scan for listening daemons, without sending any data to them. It is an error to use this option in conjunction with the -l option.
BSD netcat only
-
-4
Forces nc to use IPv4 addresses only.
-
-6
Forces nc to use IPv6 addresses only.
-
-b
Allow broadcast.
-
-C
Send CRLF as line-ending.
-
-D
Enable debugging on the socket.
-
-d
Do not attempt to read from stdin.
-
-I length
Specifies the size of the TCP receive buffer.
-
-k
Forces nc to stay listening for another connection after its current connection is completed. It is an error to use this option without the -l option.
-
-O length
Specifies the size of the TCP send buffer.
-
-P proxy_username
Specifies a username to present to a proxy server that requires authentication. If no username is specified then authentication will not be attempted. Proxy authentication is only supported for HTTP CONNECT proxies at present.
-
-q seconds
after EOF on stdin, wait the specified number of seconds and then quit. If seconds is negative, wait forever.
-
-S
Enables the RFC 2385 TCP MD5 signature option.
-
-T toskeyword
Change IPv4 TOS value. toskeyword may be one of critical, inetcontrol, lowcost, lowdelay, netcontrol, throughput, reliability, or one of the DiffServ Code Points: ef, af11 … af43, cs0 … cs7; or a number in either hex or decimal.
-
-U
Specifies to use UNIX-domain sockets.
-
-V rtable
Set the routing table to be used. The default is 0.
-
-X proxy_protocol
Requests that nc should use the specified protocol when talking to the proxy server. Supported protocols are “4” (SOCKS v.4), “5” (SOCKS v.5) and “connect” (HTTPS proxy). If the protocol is not specified, SOCKS version 5 is used.
-
-x proxy_address[:port]
Requests that nc should connect to destination using a proxy at proxy_address and port. If port is not specified, the well-known port for the proxy protocol is used (1080 for SOCKS, 3128 for HTTPS).
-
-Z
DCCP mode.
GNU netcat only
-
-c
,--close
Close connection on EOF from stdin.
-
-e
,--exec=PROGRAM
Program to exec after connect.
-
-g
,--gateway=LIST
Source-routing hop point[s], up to 8.
-
-G
,--pointer=NUM
Source-routing pointer: 4, 8, 12, …
-
-L
,--tunnel=ADDRESS:PORT
Forward local port to remote address.
-
-o
,--output=FILE
Output hexdump traffic to FILE (implies -x).
-
-t
,--tcp
TCP mode (default).
-
-V
,--version
Output version information and exit.
-
-x
,--hexdump
Hexdump incoming and outgoing traffic.
Epilogue
I uninstalled GNU netcat and installed BSD netcat btw ;)


--- layout: archive title: Zulip Chat Archive permalink: /stream/113488-general/topic/image.20factorization.20to.20functor.html ---
I have a functor (F : Type u ⥤ Type u)
using the category types as defined in
mathlib.category_theory.types.lean
and a function (f: A → F.obj A
.
I would like to define the image_factorization of this function on (S : set A)
as a : S → F.obj S
.
However, I am not able to “convince” lean that (f s ∈ F.obj S)
.
I tried both subsets and subtypes and it didn’t work.
@Qais Hamarneh Why would it be true?
You need some compatibility between f
and the functor F
, right?
Actually @Johan Commelin , you're right, it might not hold up. Forget about it.
{% endraw %}Last updated: Apr 24 2020 at 19:02 UTC


topic one
topic oneparagraph one
paragraph twotopic two
topic twoparagraph one
paragraph twotopic three
topic threeparagraph three
paragraph fourtopic four
paragraph five
paragraph sixtopic five
topic fiveparagraph seven
paragraph eighttopic six
topic sixparagraph nine
paragraph ten


https://crunchy-bot.live/api
We have a large Anime and Manga database, this is used for retrieving details about Anime or Manga
| Endpoint | /anime/details?terms={} |
| Description | Get specific Information on Anime, this endpoint requires the terms argument, Optional: limit (Max 15), legacy (default False) |
| Rate limit | 45/60s |
| Amount of content | 17,348 Items |
| Endpoint | /manga/details?terms={} |
| Description | Get specific Information on Manga, this endpoint requires the terms argument, Optional: limit (Max 15), legacy (default False) |
| Rate limit | 45/60s |
| Amount of content | 34,296 Items |
Quite possibly the largest free NSFW image API, content is rotated on a daily basis with new images being added.
We have Zero Tollerance for Loli or Lolita images.
| Endpoint | /nsfw/hentai?tag={} |
| Description |
This returns a JSON response with a "url" key, this contains the serving image.
If no tag is given the API will return a random image from all tags. A full list of tags can be found at /nsfw/tags |
| Rate limit | 120/60s |
| Amount of content | Too many |


The WebView Component
Overview
Despite the fact that Titanium gives us the opportunity to use native UI components, sometimes we still need to make use of web content. Whether it's displaying an existing website, making use of the <canvas>, or handling an RSS feed, leveraging web content is something mobile developers need to be able to do. In order to make use of a platform's native webview component, we need only use Ti.UI.WebView. This API allows us to create, display, and interact with both local and remote web content.
In the following sections we'll see exactly how we can create WebViews in our apps using the Titanium API, use both local and remote data as the source of our web content, and examine how we can use the properties and functions of the Ti.UI.WebView to enhance the user experience.
Contents
-
Using Remote WebContent with WebView
-
Using Local Web Content with WebView
-
WebView Properties and Functions
-
Performance and Interaction Concerns
Using Remote WebContent with WebView
In its simplest form, a WebView is created with the Ti.UI.createWebView() function and added to the view hierarchy just as we would any other view component. Let's look at a simple example. Here we'll display an existing website in our native app using just a few lines of code.
var win = Ti.UI.createWindow();
var webview = Ti.UI.createWebView({
url: 'http://www.appcelerator.com'
});
win.add(webview);
win.open();
As pictured above, we need only specify the url of a remote website in order to display it in a WebView. And just like other view components, we are free to resize and position the WebView any way we like. For example, if we wanted to have a smaller WebView that was only a portion of the visible screen, we could do something like this:
var win = Ti.UI.createWindow();
var webview = Ti.UI.createWebView({
url: 'http://www.appcelerator.com',
height: '200dp'
});
win.add(webview);
win.open();
The WebView itself is only 200 density independent pixels in height, but the entire webpage is viewable by scrolling vertically. By parceling our web content to a smaller portion of the screen, we are able to use the remaining space for anything we want. We can add native UI components or even more WebViews.
One of the more interesting uses of remote WebViews is displaying mobile optimized content. This is particularly useful when the content encompasses large amounts of functionality that we won't have to code for ourselves. A great example of this is the Ti.Facebook module that makes use of Facebook's default login screen via WebView for authentication. This example, along with a few others, can be found in the WebView Use Cases section of this chapter.
Using Local Web Content with WebView
Often times when dealing with web content we'll want to load it from local resources. This allows offline usage and can decrease the load time of the WebView. This web content can include HTML, CSS, and even Javascript libraries. The syntax for loading local web content is identical to that of the remote:
var win = Ti.UI.createWindow();
var webview = Ti.UI.createWebView({
url: 'local.html'
});
win.add(webview);
win.open();
local.html refers to a local HTML file included in our project. The path used by the url property when referring to local web content is relative to your project's Resources directory. This is important to note as you include more complex local web content, as we'll discuss next.
Let's say you not only want to show a local HTML file, but you also want that HTML file to have access to local CSS and Javascript files. All you need to do is remember that all local web content is available relative to your project's Resources} directory. You can think of {{Resourcez almost as a local web server root path. To illustrate this point, let's take the prior example and expand it to use local CSS and Javascript files.
local.html

<title>Local HTML</title>
<link rel="stylesheet" type="text/css" href="local.css"/>

Here some text that will be styled by the included local style sheet. If you click it,
the included local JS file will cause an alert to pop up.

local.css
p {
color: #880000;
font-weight: bold;
font-size: 24px;
}
local.js
function addParagraphAlert() {
document.getElementById('localtest').addEventListener('click', function(e) {
alert('you clicked the paragraph');
});
}
All of the above files are placed in the Resources directory of your project. Below we can see what this would look like on an iPhone:
The included HTML/CSS/JS does not have to be this simplistic, though. With local web content you can include any HTML/CSS/JS that the platform's browser will support. This include graphics libraries for <canvas> or even using jQuery inside your WebViews. You get the best of both worlds with Titanium: Access to native components along with all the power of the web.
In addition to being able to specify local HTML files, you can also add HTML dynamically to your WebViews via the html property. This can be used for adding everything from simple styled text to a full fledged webpage. Here's how you would specify HTML in your own WebView via html. This would display a very simple paragraph in an unstyled WebView.
var win = Ti.UI.createWindow();
var webview = Ti.UI.createWebView({
html: '
Here is my paragraph
'
});
win.add(webview);
win.open();
One additional, and extremely powerful, bit of functionality available to you with local WebViews is the ability for your local web content to be able to communicate bidirectionally with your Titanium code via application level events. What this means is that interactions and data from your WebViews can be shared with your native Titanium code, and vice versa. This will be discussed in more detail in the Communication Between WebViews and Titanium section.
WebView Properties and Functions
Now that you've seen how to render WebViews using both local and remote web content, let's look at some of the ways we can add more style and control to them. This includes functions, properties, and events for basic web browser navigation, data handling, loading control, and scaling.
Loading Control
Another familiar set of functionality is the ability to refresh and stop the loading of a WebView. The functions and properties listed below give us visibility into the loading state of the WebView and the ability to control it.
-
loading - A boolean property that indicates whether or not the WebView is currently loading content.
-
reload() - A function that reloads the WebView, much like a browser refresh.
-
repaint() - A function that causes the WebView to repaint its contents.
-
stopLoading() - A function that stops the loading of a WebView, much like the "stop" button in most browsers.
Data Handling & Scaling
As covered in the previous sections, passing local and remote data to the WebView is its core functionality. Additionally, we can pass in basic authentication and handle the initial scaling of that data as well.
-
setBasicAuthentication(username, password) - A function that passes basic HTTP authentication into the WebView. It takes 2 string parameters, username and password, that will be used to authenticate.
-
html - A string property containing the HTML you would like to render in the WebView.
-
scalesPageToFit - A boolean property that indicates whether or not you would like to scale the content of the WebView to fit its dimensions.
-
url - A URL property to local or remote web content. For remote content, this parameter is the web URL. For local content, this parameter is the path, relative to the project's Resources directory, to the local HTML file.
Events
WebView also has a few custom events to allow additional control over the lifecycle of a load, as well as any errors that may occur in the underlying native webview.
-
beforeload - This event is fired before the WebView starts loading its content. The url property of the event object contains the source of the content.
-
error - This event is fired when a WebView fails to load. Like the beforeload event, it has the url property. It also has a message property, which is a string that contains the details of the error.
-
load - This event is fired when the WebView has loaded.
Performance and Interaction Concerns
While WebViews give us the ability to leverage the power of the web in our apps, they do come at a cost. The WebView is on of the most expensive components to create in terms of resources and performance. Every WebView loaded requires its own rendering context and will take a moment to load, regardless of how simple its contents are.
For these reasons, it's critical that you are absolutely certain you need a WebView to create a specific functionality in your app. A good rule of thumb is that if you can recreate web content using Titanium native components, then you should do so. Minimal usage of WebViews will not likely be a problem, but their resource requirements can quickly become unmanageable if continually used. A prime example of this would be usage of WebViews in Ti.UI.TableViews. Performance is of utmost concern with TableViews and including WebViews in your TableViewRows is a recipe for sluggish performance.
On final consideration with WebViews is that they do not play well inside of other scrollable components. This is a limitation of the underlying native components. WebViews are pretty greedy when it comes to touch interactions and this will often steal those events from any containing views that have their own touch handlers. If you must include WebViews inside other scrollable components, your best bet will be to disable touch events on your WebView by setting its touchEnabled property to false.
Summary
In this section we learned how to create Ti.UI.WebViews to display local and remote web content. We explored the multitude of functions, properties, and events available to WebViews that give it extensive control over its functionality and appearance. Finally, we discussed some of the performance and interaction concerns when incorporating WebViews into your apps.
In the next section we'll learn how we can use Titanium application level events to bidirectionally communicate between embedded Javascript in a WebView and native Titanium code. This will add a whole new level of interaction between our Titanium code and web content.


Roadmap
{{version}}
We have a long list
of functionality to roll into our release schedule. The plan is to have a continuous 45 day release
cycle and add something from the functionality list shown below.
If you would like to comment or make a suggestion
head over to GitHub
wyomingsoftware/git-mobile-for-github where you can submit a GitHub Issue.
Functionality
Implemented
Profiles (view, search, followers, following,
starred repos, owned repos gists-mine, orgs, members)
Issues (view, search)
Repos (view, search)
Code (view)
Gists (view, recent)
Next Few Releases
Forks (view)
Pull Requests (view)
Roadmap
Issues (create, edit)
Events (view)
Notifications (commit_comment, create, delete, deployment,
deployment_status, fork, gollum, issue_comment, issues, member, membership, page_build, public,
pull_request_review_comment, pull_request, push, repository, release, status, team_add, watch)
Pull Requests (create)
Repos (collaborators, forks, forked from)
Code (search)
Gists (forks, forked from)
Commits (triage)
Support for Windows Phone
Everything in version 1x is read only. Look to version 2x to implement
write capabilities such as "create issues" and more.
Wyoming Software Team Members


Imprint
Imprint for this website ‐ also serves as provider identification according to § 5 Telemediengesetz (TMG)
Provider:
Technische Informationsbibliothek (TIB)
Welfengarten 1 B, 30167 Hannover
Postfach 6080, 30060 Hannover
Authorised Representative:
Prof. Dr. Sören Auer (Director of TIB)
Technische Informationsbibliothek (TIB) is a foundation of public law of the state of Lower Saxony.
Responsible Supervisory Authority:
Ministry for Science and Culture of Lower Saxony
Contact:
Customer service phone: +49<PHONE_NUMBER>
Central information desk phone: +49<PHONE_NUMBER>
Fax: +49<PHONE_NUMBER>
Email<EMAIL_ADDRESS>VAT (sales tax) registration number:
DE 214931803
Editorial Office:
Axel Klinger
Email<EMAIL_ADDRESS>Copyright Notice:
The layout of the homepage, the graphics used and the other content are protected by copyright.


The watermark factory. Loads resources and returns an object with functions
for manipulating them. resources
can be a mixed array of any of the
following: url, File
, Blob
, or Image
. The options
object is used to configure the watermark factory. It supports an init
function that is used when loading images from a url, and is invoked with the image before fetching.
It also allows type
and encoderOptions
to modify the resulting image according
to HTMLCanvasElement.toDataURL() paramters.
// load local images
watermark(['/img/coffee.jpg', '/img/logo.png']);
// load cross domain images
var options = {
init: function (img) {
img.crossOrigin = 'anonymous';
}
};
watermark(['http://web.com/a.jpg', 'http://web.com/b.jpg'], options);
// export resulting image as jpeg and lower the quality
var options = {
type: 'image/jpeg',
encoderOptions: 0.6
};
watermark(['http://web.com/a.jpg'], options);
// load a url and a file object
var upload = document.querySelector('input[type=file]').files[0];
watermark(['/img/photo.jpg', upload]);
Converts all resources into an Image
object by applying the function draw
. The draw
function receives all resources as canvases. Draw functions are expected to return the resource being watermarked.
// place a watermark in the upper left hand corner of an image
watermark(['/img/coffee.jpg', '/img/logo.png'])
.image(function (coffee, logo) {
var context = coffee.getContext('2d');
context.save();
context.globalAlpha = alpha;
context.drawImage(logo, 10, 10);
context.restore();
return target;
});
Converts all resources into a Blob
object by applying the function draw
. The draw
function receives all resources as canvases. Draw functions are expected to return the resource being watermarked. Blob
objects are useful for uploading generated watermarks.
// place a watermark in the upper left hand corner of an image
watermark(['/img/coffee.jpg', '/img/logo.png'])
.blob(function (coffee, logo) {
var context = coffee.getContext('2d');
context.save();
context.globalAlpha = alpha;
context.drawImage(logo, 10, 10);
context.restore();
return target;
});
Converts all resources into a data url by applying the function draw
. The draw
function receives all resources as canvases. This function is used to create the base case for the image()
and blob()
functions.
// place a watermark in the upper left hand corner of an image
watermark(['/img/coffee.jpg', '/img/logo.png'])
.dataUrl(function (coffee, logo) {
var context = coffee.getContext('2d');
context.save();
context.globalAlpha = alpha;
context.drawImage(logo, 10, 10);
context.restore();
return target;
});
Delegates to the Promise
that was passed to the watermark()
factory. This function is used
to do something with the result of watermarking.
// append a generated image
watermark(['/img/coffee.jpg', '/img/logo.png'])
.image(watermark.image.lowerRight(0.5))
.then(function (img) {
document.getElementById('preview').appendChild(img);
});
// upload a watermarked image
watermark(['/img/coffee.jpg', '/img/logo.png'])
.blob(watermark.text.lowerRight('watermark.js', '48px serif', '#fff', 0.5))
.then(function (blob) {
// perform upload using FormData
});
// use a data url as an image source
watermark(['/img/coffee.jpg', '/img/logo.png'])
.dataUrl(watermark.image.lowerLeft(0.5))
.then(function (url) {
document.querySelector('img').src = url;
});
Load additional resources. resources
and init
behave just as they do
in the watermark()
factory. This function is useful for loading images on top
of already generated watermarks.
// one watermark in the lower right and one in the upper left
watermark(['/img/boat.jpg', '/img/logo.png'])
.image(watermark.image.lowerRight(0.5))
.load(['/img/other-logo.png'])
.image(watermark.image.upperLeft(0.5))
.then(function (img) {
document.getElementById('#preview').appendChild(img);
});
Apply all transformations to the watermarked image and load it as a resource. Useful for general post-processing or writing additional text on a watermarked image.
// write multiple text watermarks
var text = watermark.text
watermark(['/img/shepherd.jpg'])
.image(text.lowerRight('watermark.js', '48px Josefin Slab', '#fff', 0.5))
.render()
.image(text.upperLeft('watermark.js', '48px Josefin Slab', '#fff', 0.5, 48))
.then(function (img) {
document.getElementById('#preview').appendChild(img);
});
watermark.js makes use of a canvas pool to reuse resources as much as possible. This is accomplished
with a shared pool. The destroy()
function on the watermark()
factory explicitly destroys all remaining
canvas references in the pool and should be used to clean up after doing a bunch of watermark operations.
// remove any remaining canvas references
watermark.destroy();
As noted about draw functions, they accept canvas objects and perform various operations on them to compose a single image. watermark.js comes with two namespaces featuring common draw operations for watermarks.
This namespace contains functions for positioning watermark images and controlling opacity. Most of these functions accept an alpha value and return a positioning function.
// draw the logo at the lower right corner at 50% opacity
watermark(['/img/coffee.jpg', '/img/logo.png'])
.image(watermark.image.lowerRight(0.5));
// draw the logo at the lower left corner at 50% opacity
watermark(['/img/coffee.jpg', '/img/logo.png'])
.image(watermark.image.lowerLeft(0.5));
// draw the logo at the upper right corner at 50% opacity
watermark(['/img/coffee.jpg', '/img/logo.png'])
.image(watermark.image.upperRight(0.5));
// draw the logo at the upper left corner at 50% opacity
watermark(['/img/coffee.jpg', '/img/logo.png'])
.image(watermark.image.upperLeft(0.5));
// draw the logo at the center at 50% opacity
watermark(['/img/coffee.jpg', '/img/logo.png'])
.image(watermark.image.center(0.5));
/**
* Callback for determining the x coordinate of the watermark
*
* @param {HTMLCanvasElement} coffee
* @param {HTMLCanvasElement} logo
* @return {Number}
*/
var getX = function(coffee, logo) {
return 73;
};
/**
* Callback for determining the y coordinate of the watermark
*
* @param {HTMLCanvasElement} coffee
* @param {HTMLCanvasElement} logo
* @return {Number}
*/
var getY = function(coffee, logo) {
return 63;
};
// draw the logo at an arbitrary location at 60% opacity
watermark(['/img/coffee.jpg', '/img/logo.png'])
.image(watermark.image.atPos(getX, getY, 0.6));
This namespace contains functions for positioning watermark text and controlling opacity. Most of these functions accept font styles and an alpha value and return a positioning function.
// draw 48px white text at the lower right corner at 50% opacity
watermark(['/img/coffee.jpg'])
.image(watermark.text.lowerRight('watermark.js', '48px sans-serif', '#fff', 0.5));
// draw 48px white text at the lower left corner at 50% opacity
watermark(['/img/coffee.jpg'])
.image(watermark.text.lowerLeft('watermark.js', '48px sans-serif', '#fff', 0.5));
/**
* Note: functions for drawing to the upper right and left corners
* support an additional y parameter due to browser limitations of
* the TextMetrics object used to calculate font height. When in doubt
* just use the size of your font for this parameter.
*/
// draw 48px white text at the upper right corner at 50% opacity
watermark(['/img/coffee.jpg'])
.image(watermark.text.upperRight('watermark.js', '48px sans-serif', '#fff', 0.5, 48));
// draw 48px white text at the upper left corner at 50% opacity
watermark(['/img/coffee.jpg'])
.image(watermark.text.upperLeft('watermark.js', '48px sans-serif', '#fff', 0.5, 48));
// draw 48px white text at the center at 50% opacity
watermark(['/img/coffee.jpg'])
.image(watermark.text.center('watermark.js', '48px sans-serif', '#fff', 0.5));
/**
* Callback for determining the x coordinate of the watermark
*
* @param {HTMLCanvasElement} coffee
* @param {TextMetrics} metrics
* @param {CanvasRenderingContex2D} context - context of the coffee canvas
* @return {Number}
*/
var x = function(coffee, metrics, context) {
return 73;
};
/**
* Callback for determining the y coordinate of the watermark
*
* @param {HTMLCanvasElement} coffee
* @param {TextMetrics} metrics
* @param {CanvasRenderingContex2D} context - context of the coffee canvas
* @return {Number}
*/
var y = function(coffee, metrics, context) {
return 63;
};
// draw 48px white text at an arbitrary location at 60% opacity
watermark(['/img/coffee.jpg'])
.image(watermark.text.atPos(x, y, 'watermark.js', '48px sans-serif', '#fff', 0.6));
Creating your own custom styles is easy. Since watermark.js subscribes to the functional style, a good pattern is to write functions that return functions.
watermark(['/img/coffee.jpg'])
image(myRadRotateFunction(0.5));
Keep in mind that these draw functions receive canvas objects, so in order to keep them composable it is a good idea to leave the context the way you found it.
function myRadRotateFunction(alpha) {
return function(target) {
var context = target.getContext('2d');
context.save(); // capture the state of the context
// do some cool rotating things
context.restore(); // put the context back where you found it
return target;
}
}
Note that we return the target canvas after we are done. This is required in order
for watermark.js to pass the finished product to then
when you are ready
to do something with your watermarked image.


A channel to discuss trading.  BTC goes up alts get burned, BTC goes down and alts get slaughtered
KMD seems t have some pretty smart traders so the effects get amplified cause the've been getting burned for the past 6 months
I just got into KMB so just no beginning to understand how the herd on this coin works
its an expensive lesson
blackjok3r03-Aug-18 04:38 AM
haha, yeah gave up trading as soon as bull ended... Wasn;t even good at it when the market was super exponential gain, over traded.
Holding huge bags of CHIPS lol... t looks good on blockfolio because the price on barterdex appears to be locked at 3k sat, even tough th real price is like 1k sat lol
HODLing here... try to create as much value as possible,.... but alas 1/tech seems to ring true
the more work we do, the more tech we creat the price just dumps more and more
JimD03-Aug-18 04:41 AM
ya, its pretty interesting to watch a shitcoin like EOS getting billions in funding with a Delayed PoS algorithm because the ignorant masses think its founder is some kind of genius. Of course its going to have massive TPS, its not actually decentralized.
ohh well, at least I sold my nano. That coin was a horror show
1
blackjok3r03-Aug-18 04:46 AM
friend of mine got a bunch of nano for less than $1, when it got to $50 I told him to sell it... he didnt.
Haven't really seen him since lol
BlackJesus03-Aug-18 04:46 AM
I'm loving these kmd prices
soon i may be a whale lol
blackjok3r03-Aug-18 04:47 AM
haha Not me... I had to sel like 4x the amount to pay hosting fees this month that I did a few months ago
although we did buy some hardware upgrades, and managed to fund all thta at $1.43 before the huge dump at least.
Deleted User03-Aug-18 04:47 AM
Anyone in aus wanna buy my ryzen 2700x + x470 mobo + nhd15 + 4gb ram hahahhahahahahha. Got it for $920 aus.
Young dude was here a few days ago asking about a gaming system
does the mobo have 2x16 PCI-E slots?

Kitchen Table03-Aug-18 04:52 AM
Looks like it might correct back. will keep an eye out but good sign some bottoms have been met.
Deleted User03-Aug-18 04:53 AM
Locking in prices while its current :p if anyone wants to grab the mobo ram cpu and cooler, itll be 410 komodo
blackjok3r03-Aug-18 04:54 AM
I might just have enough. I think.
DM in a minute
1
Cryptoon03-Aug-18 06:16 AM
I got a feeling many people are ready to buy the dip hard...
coingirl8703-Aug-18 06:31 AM
Buy hard
Sounds Like a movie with Bruce Willis
[TPUX] Djith Wattignies03-Aug-18 07:01 AM
G.. what a carnage.. whats going oooonn!
cascrypto03-Aug-18 07:07 AM
is their finnaly some volume or is dispair still not their, i must confes my dispair is their
Cryptoon03-Aug-18 07:33 AM
50 shades of reeeeekt
blackjok3r03-Aug-18 07:40 AM
well... to be fair BTC broke down from 7777 so this was obviously going to happen
The CEO of leading cryptocurrency exchange Binance says any general smart contract platform (i.e. Ethereum, EOS) will not be fast enough to achieve success in the long run. In a new interview with Fortune, Changpeng Zhao (“CZ”) says he believes they will be overtaken by ...
Binance CEO Changpeng "CZ" Zhao shares big ideas for the future of crypto and the blockchain.
on Fortune, awesome !
(Komodo is cited again)
Hollowman900003-Aug-18 10:39 AM
Have we started the fire? (In the middle of the alt coin apocalypse)
Is binance telegraphing what platform their chain is going to be based on @jl777c
jl777c03-Aug-18 10:43 AM
CZ is a smart guy and sees the future direction blockchain advances needs to take. just like ASIC took over mining, special purpose blockchains will overtake general purpose ones. having a single blockchain is just not a scalable solution, if only due to txfee for any single chain that gets popular
Hollowman900003-Aug-18 11:32 AM
Fortune article was good
Deleted User03-Aug-18 11:34 AM
awaiting fiat to exchange
please hold rocket ships off for another hour
modereck03-Aug-18 11:37 AM
I bought more kmd
msybe i can reach 500kmd soon
kmd pumping right now
Bittersweet03-Aug-18 11:55 AM
Why? Why pamp?
This is not normal
pinkolin03-Aug-18 11:56 AM
Volume goes up, but maybe by current hodlers
But maybe we get some attention now
snowdamn03-Aug-18 11:58 AM
when it happens it will happen fast
this is nothing
pinkolin03-Aug-18 11:58 AM
I still believe and hodling
But it will not be now
Maybe November
Maybe next year
pinkolin03-Aug-18 12:06 PM
20k floor is close
Sherdogz03-Aug-18 12:07 PM
So why the pump?


Example of MNA - Resistors
A resistor follows Ohm's law. Let us assume that the resistor is connected between two nodes A and B.
Then Ohm's law dictates that
$$\frac{v_A - v_B}{R} = i_R$$
The resistor current \(i_R\) will flow out of node A, and into node B, so we have contributions to row A and row B:
$$ \begin{aligned} f_A(...,v_A,...,v_B,...) = +i_R &=& \frac{1}{R}v_A &-\frac{1}{R}v_B\\ f_B(...,v_A,...,v_B,...) = -i_R &=& -\frac{1}{R}v_A &+\frac{1}{R}v_B \end{aligned}$$
Our convention is that a current flowing out of a node is positive. Now we can compute the contributions to the Y-matrix:
$$\begin{aligned} Y_{A,A} &= \frac{\partial f_A}{\partial v_A} = \frac{1}{R}\\ Y_{A,B} &= \frac{\partial f_A}{\partial v_B} = -\frac{1}{R}\\ Y_{B,A} &= \frac{\partial f_B}{\partial v_A} = -\frac{1}{R}\\ Y_{B,B} &= \frac{\partial f_B}{\partial v_B} = \frac{1}{R} \end{aligned}$$
All other Y-matrix contributions are 0. Similarly, we calculate the contributions to the RHS vector:
$$\begin{aligned} RHS_A &= \pmb J_A\pmb x^{(k)} - f_A(...,v_A^{(k)},...,v_B^{(k)},...)\\ &=\frac{v_A}{R}-\frac{v_B}{R}-\left(\frac{v_A}{R}-\frac{v_B}{R}\right )\\ &=0\\ RHS_B &= \pmb J_B\pmb x^{(k)} - f_B(...,v_A^{(k)},...,v_B^{(k)},...)\\ &=\frac{v_B}{R}-\frac{v_A}{R}-\left(\frac{v_B}{R}-\frac{v_A}{R}\right )\\ &=0 \end{aligned}$$
The first and second terms for the RHS vector cancel each other out. This turns out to be a general property of linear components. Another consequence is that a step of the iterative method is identical to regular Nodal Analysis, and we only need one iteration to find the right solution if we only have linear components. Once a nonlinear component is introduced, a single iteration will not be sufficient anymore.
To summarize:
- During the creation of the IBiasingBehavior for a resistor, 4 Y-matrix elements are allocated: \(Y_{A,A}, Y_{A,B}, Y_{B,A}, Y_{B,B}\). It does not need RHS vector elements because they are always 0.
- When loading the Y-matrix, the behavior will add the following values to these matrix elements.
$$\begin{aligned} Y_{A,A} &+= \frac{1}{R} \\ Y_{A,B} &-= \frac{1}{R} \\ Y_{B,A} &-= \frac{1}{R} \\ Y_{B,B} &+= \frac{1}{R} \end{aligned}$$
- The simulator will give all other components in the circuit a chance to load the matrix with their contributions.


Jobs for You!
| ID | job_title | job_location | job_type | job_skills | created_date |
|---|---|---|---|---|---|
| {{ job.pk }} | {{ job.job_title }} | {{ job.job_location }} | {{ job.job_type }} | {{ job.job_skills }} | {{ job.created_date }} |
{% include "snippets/header.html" %}
{% include "snippets/navbar.html" %}| ID | job_title | job_location | job_type | job_skills | created_date |
|---|---|---|---|---|---|
| {{ job.pk }} | {{ job.job_title }} | {{ job.job_location }} | {{ job.job_type }} | {{ job.job_skills }} | {{ job.created_date }} |


perl5202delta - what is new for perl v5.20.2
This document describes differences between the 5.20.1 release and the 5.20.2
release.
If you are upgrading from an earlier release such as 5.20.0, first
read perl5201delta, which describes differences between 5.20.0 and
5.20.1.
There are no changes intentionally incompatible with 5.20.1. If any exist, they
are bugs, and we request that you submit a report. See "Reporting
Bugs" below.
- attributes has been upgraded from version 0.22 to 0.23.
The usage of "memEQs" in the
XS has been corrected. [perl #122701]
<https://rt.perl.org/Ticket/Display.html?id=122701>
- Data::Dumper has been upgraded from version 2.151 to 2.151_01.
Fixes CVE-2014-4330 by adding a configuration variable/option
to limit recursion when dumping deep data structures.
- Errno has been upgraded from version 1.20_03 to 1.20_05.
Warnings when building the XS on Windows with the Visual C++
compiler are now avoided.
- feature has been upgraded from version 1.36 to 1.36_01.
The "postderef" feature has
now been documented. This feature was actually added in Perl 5.20.0 but
was accidentally omitted from the feature documentation until now.
- IO::Socket has been upgraded from version 1.37 to 1.38.
Document the limitations of the connected() method.
[perl #123096]
<https://rt.perl.org/Ticket/Display.html?id=123096>
- Module::CoreList has been upgraded from version 5.020001 to 5.20150214.
The list of Perl versions covered has been updated.
- PathTools has been upgraded from version 3.48 to 3.48_01.
A warning from the gcc compiler is now avoided when
building the XS.
- PerlIO::scalar has been upgraded from version 0.18 to 0.18_01.
Reading from a position well past the end of the scalar now
correctly returns end of file. [perl #123443]
<https://rt.perl.org/Ticket/Display.html?id=123443>
Seeking to a negative position still fails, but no longer
leaves the file position set to a negation location.
"eof()" on a
"PerlIO::scalar" handle now properly
returns true when the file position is past the 2GB mark on 32-bit
systems.
- Storable has been upgraded from version 2.49 to 2.49_01.
Minor grammatical change to the documentation only.
- VMS::DCLsym has been upgraded from version 1.05 to 1.05_01.
Minor formatting change to the documentation only.
- VMS::Stdio has been upgraded from version 2.4 to 2.41.
Minor formatting change to the documentation only.
perlunicook
This document, by Tom Christiansen, provides examples of handling
Unicode in Perl.
perlexperiment
- •
- Added reference to subroutine signatures. This feature was actually added
in Perl 5.20.0 but was accidentally omitted from the experimental feature
documentation until now.
perlpolicy
- •
- The process whereby features may graduate from experimental status has now
been formally documented.
perlsyn
- •
- An ambiguity in the documentation of the ellipsis statement has been
corrected. [perl #122661]
<https://rt.perl.org/Ticket/Display.html?id=122661>
The following additions or changes have been made to diagnostic output,
including warnings and fatal error messages. For the complete list of
diagnostic messages, see perldiag.
- Bad symbol for scalar is now documented. This error is not new, but was
not previously documented here.
- Missing right brace on \N{} is now documented. This error is not new, but
was not previously documented here.
- •
- The test script re/rt122747.t has been added to verify that perl
#122747 <https://rt.perl.org/Ticket/Display.html?id=122747> remains
fixed.
IRIX and Tru64 platforms are working again. (Some "make
test" failures remain.)
- AIX now sets the length in "getsockopt"
correctly. [perl #120835]
<https://rt.perl.org/Ticket/Display.html?id=120835>, [cpan #91183]
<https://rt.cpan.org/Ticket/Display.html?id=91183>, [cpan #85570]
<https://rt.cpan.org/Ticket/Display.html?id=85570>
- In Perl 5.20.0, $^N accidentally had the internal
UTF8 flag turned off if accessed from a code block within a regular
expression, effectively UTF8-encoding the value. This has been fixed.
[perl #123135]
<https://rt.perl.org/Ticket/Display.html?id=123135>
- Various cases where the name of a sub is used (autoload, overloading,
error messages) used to crash for lexical subs, but have been fixed.
- An assertion failure when parsing "sort"
with debugging enabled has been fixed. [perl #122771]
<https://rt.perl.org/Ticket/Display.html?id=122771>
- Loading UTF8 tables during a regular expression match could cause
assertion failures under debugging builds if the previous match used the
very same regular expression. [perl #122747]
<https://rt.perl.org/Ticket/Display.html?id=122747>
- Due to a mistake in the string-copying logic, copying the value of a state
variable could instead steal the value and undefine the variable. This
bug, introduced in Perl 5.20, would happen mostly for long strings (1250
chars or more), but could happen for any strings under builds with
copy-on-write disabled. [perl #123029]
<https://rt.perl.org/Ticket/Display.html?id=123029>
- Fixed a bug that could cause perl to execute an infinite loop during
compilation. [perl #122995]
<https://rt.perl.org/Ticket/Display.html?id=122995>
- On Win32, restoring in a child pseudo-process a variable that was
"local()"ed in a parent pseudo-process
before the "fork" happened caused memory
corruption and a crash in the child pseudo-process (and therefore OS
process). [perl #40565]
<https://rt.perl.org/Ticket/Display.html?id=40565>
- Tainted constants evaluated at compile time no longer cause unrelated
statements to become tainted. [perl #122669]
<https://rt.perl.org/Ticket/Display.html?id=122669>
- Calling "write" on a format with a
"^**" field could produce a panic in
sv_chop() if there were insufficient arguments or if the variable
used to fill the field was empty. [perl #123245]
<https://rt.perl.org/Ticket/Display.html?id=123245>
- In Perl 5.20.0, "sort CORE::fake" where
'fake' is anything other than a keyword started chopping of the last 6
characters and treating the result as a sort sub name. The previous
behaviour of treating "CORE::fake" as a sort sub name has been
restored. [perl #123410]
<https://rt.perl.org/Ticket/Display.html?id=123410>
- A bug in regular expression patterns that could lead to segfaults and
other crashes has been fixed. This occurred only in patterns compiled with
"/i", while taking into account the
current POSIX locale (this usually means they have to be compiled within
the scope of "use locale"), and
there must be a string of at least 128 consecutive bytes to match. [perl
#123539] <https://rt.perl.org/Ticket/Display.html?id=123539>
- "qr/@array(?{block})/" no longer dies
with "Bizarre copy of ARRAY". [perl #123344]
<https://rt.perl.org/Ticket/Display.html?id=123344>
- "gmtime" no longer crashes with
not-a-number values. [perl #123495]
<https://rt.perl.org/Ticket/Display.html?id=123495>
- Certain syntax errors in substitutions, such as
"s/${<>{})//", would crash, and
had done so since Perl 5.10. (In some cases the crash did not start
happening until Perl 5.16.) The crash has, of course, been fixed. [perl
#123542] <https://rt.perl.org/Ticket/Display.html?id=123542>
- A memory leak in some regular expressions, introduced in Perl 5.20.1, has
been fixed. [perl #123198]
<https://rt.perl.org/Ticket/Display.html?id=123198>
-<EMAIL_ADDRESS>"a");" would crash. The
"FF_CHECKNL" case in
pp_formline() didn't set the pointer used to mark the chop
position, which led to the "FF_MORE"
case crashing with a segmentation fault. This has been fixed. [perl
#123538] <https://rt.perl.org/Ticket/Display.html?id=123538> [perl
#123622] <https://rt.perl.org/Ticket/Display.html?id=123622>
- A possible buffer overrun and crash when parsing a literal pattern during
regular expression compilation has been fixed. [perl #123604]
<https://rt.perl.org/Ticket/Display.html?id=123604>
- •
- It is a known bug that lexical subroutines cannot be used as the
"SUBNAME" argument to
"sort". This will be fixed in a future
version of Perl.
- •
- A regression has been fixed that was introduced in Perl 5.20.0 (fixed in
Perl 5.20.1 as well as here) in which a UTF-8 encoded regular expression
pattern that contains a single ASCII lowercase letter does not match its
uppercase counterpart. [perl #122655]
<https://rt.perl.org/Ticket/Display.html?id=122655>
Perl 5.20.2 represents approximately 5 months of development since Perl 5.20.1
and contains approximately 6,300 lines of changes across 170 files from 34
authors.
Excluding auto-generated files, documentation and release tools,
there were approximately 1,900 lines of changes to 80 .pm, .t, .c and .h
files.
Perl continues to flourish into its third decade thanks to a
vibrant community of users and developers. The following people are known to
have contributed the improvements that became Perl 5.20.2:
Aaron Crane, Abigail, Andreas Voegele, Andy Dougherty, Anthony
Heading, Aristotle Pagaltzis, Chris 'BinGOs' Williams, Craig A. Berry,
Daniel Dragan, Doug Bell, Ed J, Father Chrysostomos, Glenn D. Golden,
H.Merijn Brand, Hugo van der Sanden, James E Keenan, Jarkko Hietaniemi, Jim
Cromie, Karen Etheridge, Karl Williamson, kmx, Matthew Horsfall, Max
Maischein, Peter Martini, Rafael Garcia-Suarez, Ricardo Signes, Shlomi Fish,
Slaven Rezic, Steffen Mueller, Steve Hay, Tadeusz SoXnierz, Tony Cook, Yves
Orton, AEvar Arnfjoerd` Bjarmason.
The list above is almost certainly incomplete as it is
automatically generated from version control history. In particular, it does
not include the names of the (very much appreciated) contributors who
reported issues to the Perl bug tracker.
Many of the changes included in this version originated in the
CPAN modules included in Perl's core. We're grateful to the entire CPAN
community for helping Perl to flourish.
For a more complete list of all of Perl's historical contributors,
please see the AUTHORS file in the Perl source distribution.
If you find what you think is a bug, you might check the articles recently
posted to the comp.lang.perl.misc newsgroup and the perl bug database at
https://rt.perl.org/ . There may also be information at http://www.perl.org/ ,
the Perl Home Page.
If you believe you have an unreported bug, please run the perlbug
program included with your release. Be sure to trim your bug down to a tiny
but sufficient test case. Your bug report, along with the output of
"perl -V", will be sent off to
<EMAIL_ADDRESS>to be analysed by the Perl porting team.
If the bug you are reporting has security implications, which make
it inappropriate to send to a publicly archived mailing list, then please
send it to<EMAIL_ADDRESS>This points to a closed
subscription unarchived mailing list, which includes all the core
committers, who will be able to help assess the impact of issues, figure out
a resolution, and help co-ordinate the release of patches to mitigate or fix
the problem across all platforms on which Perl is supported. Please only use
this address for security issues in the Perl core, not for modules
independently distributed on CPAN.
The Changes file for an explanation of how to view exhaustive details on
what changed.
The INSTALL file for how to build Perl.
The README file for general stuff.
The Artistic and Copying files for copyright
information.


{% extends "base.html" %} {% block title %}
Medieval catalogues > BENEDICTINES > Peterborough > Books given by Abbot Adam of Boothby (1321-38)
{% endif %}5 identified entries found.
All data was derived from the List of Identifications by Professor Richard Sharpe.
{% if not printing %}
A key to codes used in the List is available (opens in new tab).{% endif %}


<input type="text" value="75" class="dial">
<script>
$(function() {
$(".dial").knob();
});
</script>
Options are provided as attributes ‘data-option’:
<input type="text" class="dial" data-min="-50" data-max="50">
… or in the “knob()” call :
$(".dial").knob({
'min':-50
,'max':50
});
The following options are supported :
Behaviors : * min : min value | default=0. * max : max value | default=100. * step : step size | default=1. * angleOffset : starting angle in degrees | default=0. * angleArc : arc size in degrees | default=360. * stopper : stop at min & max on keydown/mousewheel | default=true. * readOnly : disable input and events | default=false.
UI : * cursor : display mode “cursor”, cursor size could be changed passing a numeric value to the option, default width is used when passing boolean value “true” | default=gauge. * thickness : gauge thickness. * lineCap : gauge stroke endings. | default=butt, round=rounded line endings * width : dial width. * displayInput : default=true | false=hide input. * displayPrevious : default=false | true=displays the previous value with transparency. * fgColor : foreground color. * inputColor : input value (number) color. * font : font family. * fontWeight : font weight. * bgColor : background color.
<script>
$(".dial").knob({
'release' : function (v) { /*make something*/ }
});
</script>
‘release’ : executed on release
Parameters : + value : int, current value
‘change’ : executed at each change of the value
Parameters : + value : int, current value
‘draw’ : when drawing the canvas
Context : - this.g : canvas context 2D (see Canvas documentation) - this.$ : jQuery wrapped element - this.o : options - this.i : input - … console.log(this);
‘cancel’ : triggered on [esc] keydown
‘error’ : called if the browser doesn’t support canvases and the plugin didn’t initialize as a result
The scope (this) of each hook function is the current Knob instance (refer to the demo code).
<input type="text" value="75" class="dial">
<script>
$(".dial").knob({
'change' : function (v) { console.log(v); }
});
</script>
<script>
$('.dial')
.trigger(
'configure',
{
"min":10,
"max":40,
"fgColor":"#FF0000",
"skin":"tron",
"cursor":true
}
);
</script>
<script>
$('.dial')
.val(27)
.trigger('change');
</script>
Tested on Chrome, Safari, Firefox, IE 9.0.
Copyright (C) 2013 Anthony Terrien
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


quarto
An open-source scientific and technical publishing system built on Pandoc.
More information: home page
- Create a new project:
quarto create-project path/to/destination_directory --type book|default|website
- Create a new blog website:
quarto create-project path/to/destination_directory --type website --template blog
- Render input file(s) to different formats:
quarto render path/to/file.qmd|rmd|ipynb --to html|pdf|docx
- Render and preview a document or a website:
quarto preview path/to/destination_directory|path/to/file
- Publish a document or project to Quarto Pub, Github Pages, RStudio Connect or Netlify:
quarto publish quarto-pub|gh-pages|connect|netlify


nodemon reload, automatically.
Nodemon is a utility depended on by over 1.5 million projects, that will monitor for any changes in your source and automatically restart your server. Perfect for development.
Swap nodemon instead of node to run your code, and now your process will automatically restart when your code changes.
Features
Automatic restarting of application.
Detects default file extension to monitor.
Default support for node but easy to run any executable, such as python, ruby, make, etc.
Ignoring specific files or directories.
Watch specific directories.
Works with server applications or one time run utilities and REPLs.
Scriptable through node require statements.
Open source and available on github.
_________________________________________________________


UFC 244 Odds And Prop Bets You Won’t Believe
by Brian MaziqueSports fans will bet on almost anything, and that concept will be on full display Saturday night in New York at Madison Square Garden. UFC 244 is a mega event which features Nate Diaz taking on Jorge Masvidal in a highly anticipated match.The excitement around UFC 244 is proof the promotion doesn’t need to have a title on the line in the main event of a pay-per-view to generate interest.
According to ListenFirst, a social media listening and analytics firm, the Top-5 UFC-related videos on the promotion’s YouTube and Facebook pages generated 6.5 million views this week. All of those videos were related to UFC 244 in some way.
Any time there is this much interest in a sporting event, you can be sure there will be traditional and prop bets available. Prop bets can be pretty outrageous for major events, but when the chief participants are colorful characters like Diaz and Masvidal, the possible side wagers are even more over the top.
Take a look at three of the more amusing ones, per BetOnline.
If Donald Trump is Shown or Announced Will the Fans Boo?
- Yes -230
- No +190
President Trump is scheduled to be in New York at MSG for the event. Trump and UFC President Dana White have been friends for years, and the former has had several connections with combat sports throughout his years of prominence.
Trump is one of the most polarizing people on Earth, so it’s likely he’ll generate an emotional response of some kind from the fans in the building.
Number of Times Diaz Says F-word
- Under 2.5 -200
- Over 2.5 +150
Diaz is known for his foul mouth, rebellious persona, brilliant Jiu-Jitsu and boxing. Win or lose, Diaz is liable to drop a few F-bombs. I think everyone would be shocked if he kept it completely clean, especially on a pay-per-view.
The only question is how many times will let Diaz let the F-word fly?
Will Diaz Give the Middle Finger?
- No -500
- Yes +300
Few fighters have a signature hand signal. Even fewer of them are as notorious for flipping everyone the bird. If you’re looking to get in on the action with one of these bets, I’d probably say consider wagering a few bucks on Diaz not pushing up his middle finger.
If Masvidal beats him clean, perhaps via TKO or KO, Diaz may not be feeling quite as defiant as normal. He’s only been stopped once, but Masvidal is the favorite in this matchup. If you believe Masvidal wins, and even more specifically by stoppage, you might want to bet on Diaz keeping his middle finger down.


alligata
Support tools for WebAudio API and
wani
alligata is a collection of support tools/libraries for WebAudio API /
wani
users.
DSP Circuit Compiler
Compiles Arithmetic expressions to WebAudio Node Circuit.


Class: Helium::Collection
- Inherits:
-
Object
- Object
- Helium::Collection
- Includes:
- Enumerable
- Defined in:
- lib/helium/collection.rb
Instance Attribute Summary collapse
-
#filter_criteria ⇒ Object
readonly
Returns the value of attribute filter_criteria.
Instance Method Summary collapse
-
#+(other) ⇒ Object
TODO: could support something like label.sensors << new_sensor see Label#add_sensors for where it would be applied.
- #-(other) ⇒ Object
-
#==(other) ⇒ Object
Collections are considered equal if they contain the same resources as determined by the resources' ids.
- #[](index) ⇒ Object
-
#add_relationships(items) ⇒ Object
Adds resources of the same type to the collection related to the '@belongs_to' resource.
-
#all ⇒ Helium::Collection
Returns all resources.
-
#collection ⇒ Resource
Returns an array of the Resources belonging to the Collection.
- #each ⇒ Object
-
#initialize(opts) ⇒ Collection
constructor
A new instance of Collection.
- #inspect ⇒ Object
-
#last ⇒ Object
NOTE: if we implement pagination, we'll need to rethink this.
-
#remove_relationships(items) ⇒ Object
Removes resources of the same type to the collection related to the '@belongs_to' resource.
-
#replace_relationships(items) ⇒ Object
Replaces resources of the same type to the collection related to the '@belongs_to' resource.
- #to_json(*options) ⇒ Object
-
#where(criteria) ⇒ Collection
Uses metadata filtering (https://docs.helium.com/api/v1/metadata/index.html#filtering) to search for a collection of resources matching the search parameters.
Constructor Details
#initialize(opts) ⇒ Collection
Returns a new instance of Collection
7 8 9 10 11 12 13 |
# File 'lib/helium/collection.rb', line 7 def initialize(opts) @client = opts.fetch(:client) @klass = opts.fetch(:klass) @belongs_to = opts.fetch(:belongs_to, nil) @filter_criteria = {} end |
Instance Attribute Details
#filter_criteria ⇒ Object (readonly)
Returns the value of attribute filter_criteria
5 6 7 |
# File 'lib/helium/collection.rb', line 5 def filter_criteria @filter_criteria end |
Instance Method Details
#+(other) ⇒ Object
TODO: could support something like label.sensors << new_sensor see Label#add_sensors for where it would be applied
60 61 62 |
# File 'lib/helium/collection.rb', line 60 def +(other) collection + other end |
#-(other) ⇒ Object
64 65 66 |
# File 'lib/helium/collection.rb', line 64 def -(other) collection - other end |
#==(other) ⇒ Object
Collections are considered equal if they contain the same resources as determined by the resources' ids
74 75 76 |
# File 'lib/helium/collection.rb', line 74 def ==(other) self.map(&:id).sort == other.map(&:id).sort end |
#[](index) ⇒ Object
68 69 70 |
# File 'lib/helium/collection.rb', line 68 def [](index) collection[index] end |
#add_relationships(items) ⇒ Object
Adds resources of the same type to the collection related to the '@belongs_to' resource
85 86 87 88 |
# File 'lib/helium/collection.rb', line 85 def add_relationships(items) body = relationship_request_body(items) @client.post(relationship_path, body: body) end |
#all ⇒ Helium::Collection
Returns all resources
18 19 20 21 |
# File 'lib/helium/collection.rb', line 18 def all @filter_criteria = {} self end |
#collection ⇒ Resource
Returns an array of the Resources belonging to the Collection
42 43 44 |
# File 'lib/helium/collection.rb', line 42 def collection fetch_collection end |
#each ⇒ Object
46 47 48 |
# File 'lib/helium/collection.rb', line 46 def each collection.each{ |element| yield element } end |
#inspect ⇒ Object
50 51 52 |
# File 'lib/helium/collection.rb', line 50 def inspect collection end |
#last ⇒ Object
NOTE: if we implement pagination, we'll need to rethink this
79 80 81 |
# File 'lib/helium/collection.rb', line 79 def last collection.last end |
#remove_relationships(items) ⇒ Object
Removes resources of the same type to the collection related to the '@belongs_to' resource. An empty array removes all resources.
99 100 101 102 |
# File 'lib/helium/collection.rb', line 99 def remove_relationships(items) body = relationship_request_body(items) @client.delete(relationship_path, body: body) end |
#replace_relationships(items) ⇒ Object
Replaces resources of the same type to the collection related to the '@belongs_to' resource. An empty array removes all resources.
92 93 94 95 |
# File 'lib/helium/collection.rb', line 92 def replace_relationships(items) body = relationship_request_body(items) @client.patch(relationship_path, body: body) end |
#to_json(*options) ⇒ Object
54 55 56 |
# File 'lib/helium/collection.rb', line 54 def to_json(*) collection.to_json(*) end |
#where(criteria) ⇒ Collection
Uses metadata filtering (https://docs.helium.com/api/v1/metadata/index.html#filtering) to search for a collection of resources matching the search parameters
35 36 37 38 |
# File 'lib/helium/collection.rb', line 35 def where(criteria) add_filter_criteria(criteria) self end |


Our AI will write a story for you. It was trained on the text from millions of web pages, using machine learning to figure out what to write. Each story it creates is unique and not something that ever existed before.
The AI model takes in the data uploaded by the user and gets trained on the same. The training time could be more or less depending upon the number of epochs provided by the user.
This app challenges you to give these documents a machine learning makeover. Improving the ease of data enhancement will mesmerize you.
The AI used sequential model Long Short Term Memory algorithm for training purpose, and along with various tools like Pandas, Numpy, Keras etc. goes on to generate real like story.
Applications of the App :
This app could be used to generate new type of story or poem never existed before.
Developer's Details
Name: Shobhit Srivastava
Email Id : shobhitsrivastava18th@gmail.com


Methods
find(value) → {Node}
Returns the first node that value matches.
Parameters:
| Name | Type | Description |
|---|---|---|
value |
any | Value to be found |
Returns:
Node with that value
- Type
- Node
forEach(callbackFn)
Traverses the list and executes the callback function for each element in the list.
The first argument of the callback function is the node's value, the second one is the index.
Parameters:
| Name | Type | Description |
|---|---|---|
callbackFn |
valueCallbackFn | Function invoked for each element in the list. |
get(targetIndex) → {Node}
Retrieves the Node with a given index
Parameters:
| Name | Type | Description |
|---|---|---|
targetIndex |
number | Wanted node's index |
Returns:
Found node
- Type
- Node
getHead() → {Node}
Returns the head of the list (the first element)
Returns:
The head node (the first node in the list)
- Type
- Node
getLength() → {number}
Computes the length of the list
Returns:
The length of the list.
- Type
- number
getTail() → {Node}
Returns the tail of the list (the last element)
Returns:
The tail node (the last node in the list)
- Type
- Node
getValues() → {Array.<any>}
Converts the list to an array
Returns:
Array of values from the list
- Type
- Array.<any>
map(callbackFn) → {List}
Executes callbackFn on each item from the list and returns the results as another list.
Parameters:
| Name | Type | Description |
|---|---|---|
callbackFn |
valueCallbackFn | Function invoked for each element in the list |
Returns:
Transformed list
- Type
- List
push(value, index) → {List}
Adds a value at a given index
Parameters:
| Name | Type | Description |
|---|---|---|
value |
any | Value to be added. |
index |
number | Index at which the value should be added. |
Throws:
-
Index must not exceed list size.
- Type
- Error
Returns:
This list. Allows for chainability.
- Type
- List
pushBack(newValue) → {List}
Adds a value to the end of the list
Parameters:
| Name | Type | Description |
|---|---|---|
newValue |
any | A value to be added |
Returns:
This list. Allows for chainability
- Type
- List
reduce(callbackFn, startingValueopt, extractValuesopt) → {any}
Reduces the list to a single value
Parameters:
| Name | Type | Attributes | Default | Description |
|---|---|---|---|---|
callbackFn |
reduceCallbackFN | Callback which reduces the list. | ||
startingValue |
any |
<optional> |
Value to initiate the reducing with. | |
extractValues |
boolean |
<optional> |
true | Decides on what will be passed to the callbackFn, either values or whole nodes. |
Returns:
Reduced value
- Type
- any
remove(valueToRemove) → {List}
Removes nodes with specific values from the list
Parameters:
| Name | Type | Description |
|---|---|---|
valueToRemove |
any | A value to be removed |
Returns:
This list. Allows for chainability.
- Type
- List


I'm a senior software engineer at Snorkel AI, on the infrastructure team, working in Python on backend features that support the foundation of our ML platform.


Dead Sea Marathon
Amman JOR
Race Winners
(20 runnings)
13 Apr 2007
07 Apr 2006
15 Apr 2005
16 Apr 2004
2003
18 Oct 2002
06 Apr
2001
2000
1999
1998
1997
1996
1995
Notes: 1994 is believed to have been the inaugural year. This course is
point-to-point and drops 30 m/km.
05 Apr
2013
2:28:26
Ayman Hussein (JOR)
3:11:45
Sajood Al-Khotaba (JOR)
06 Apr
2012
2:31:41
Fathi Suleiman (JOR)
3:20:37
Naheda Al Bawat (JOR)
08 Apr
2011
2:22:01
Mithqal Al-Abadi (JOR)
3:24:33
Kristin Ricci (USA)
09 Apr
2010
2:33:45
Mohammad Abu-Rezeq (JOR)
3:17:05
Chris Peeters (BEL)
10 Apr
2009
2:11:14
Suleiman Al-Zaboun (JOR)
2:51:39
Kholoud Atieh (JOR)
11 Apr
2008
2:28:36
Erhayel Al-Kafraini (JOR)
3:34:00
Nina Kamp (USA)
2:28:57
Anas Alawi (JOR)
3:04:36
Christina Suza (FRA)
2:24:54
Bader Al Khawaldeh (JOR)
3:08:28
Esther vanHoof (NED)
2:23:32
Salameh Abdelkarim al-Agra (JOR)
3:12:45
Rosario Moreno (ESP)
2:23:15
Francisco Lazaro Sesa (ESP)
3:47:06
Christine Trommer (GER)
---
n/a
---
n/a
2:35:00
Mured Shehab (IRQ)
3:50:14
Janice El Naif-2
2:27:14
Omar al-Jabour (JOR)
2:58:21
Katerina Pratsi (CYP)
2:46:34
Ra'ed Karageh (JOR)
3:50:52
Lama Attab (JOR)
2:41:30
Khaled al-Sheikh (JOR)
3:59:13
Janice El Naif (GBR)
3:03:45
Muhammed al-Sawari (JOR)
3:26:38
Valerie Legrain (GBR)
3:00:50
Percy Dunn (RSA)
---
n/a
---
n/a
---
n/a
---
n/a
---
n/a
1994
---
n/a
---
n/a
Most Wins
(1995-date)
Men
No man has won more than once, according to available
information.
Women
No woman has won more than once, according to
available information.
Prize Money
(ADR qualified runners)
No information on prize money has been received for this race.
Race Time Bias
(sec/km)
Insufficient information to calculated the race time bias.
Competitive Level
(1990-date)
Insufficient information to calculated the competitive level.
Quality Performances
Men
<2:12 1
<2:13 2
<2:14 2
<2:15 2
<2:16 2
<2:17 2
<2:18 2
<2:19 3
<2:20 3
Women
no women under 2:50
Last Updated on 25 May 2013
Contributors: Klaas Loonstra (14), Franco Civai (15)