Docman
Introduction
Welcome to the Docman Api. Docman is an Api for managing documents. Implemented with an Admin, Editors and users. It provides all that is essential for a management system, users can create documents complete with roles and privileges. Each document defines its access right and the date which it was created.
Authentication
All routes apart from /api/v1/users
and /api/v1/users/login
require a jwt token to be accessed. The token is generated after a successful login or signup. All tokens are valid for 24 hours. Set the header in your API
client with the token provided.
Authorization: token
Users
Login User
This Route logs a user in
Request:
{
"email"<EMAIL_ADDRESS>"password": "tolu"
}
Response:
{
"message": "Login successful"
"token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6MSwidXNlcm5hbWUiOiJhZG1pbiIsInJvbGVJZCI6MSwiaWF0IjoxNDk2MDA5MjQxLCJleHAiOjE0OTY2MTQwNDF9.hkWYITDnqi7paQjhkqhh5Fe0yAiPf34Ffji9jKHQ_Ik",
}
Request
- Endpoint: POST:
api/v1/users/login
Response
- Status:
200: OK
- Body
(application/json)
Create User
This route creates a new user
Request:
{
"name": "ade",
"email"<EMAIL_ADDRESS>"password": "ade"
}
Response:
{
"message": "Registration Was Succesfull, You have been logged in",
"token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6NCwidXNlcm5hbWUiOiJrZW5wYWNoaSIsInJvbGVJZCI6MiwiaWF0IjoxNDk2MDAxNTE4LCJleHAiOjE0OTY2MDYzMTh9.GjmEBd_9LH9b_Gdabgdfit2HfkFBZfPshquUnAmRXV8"
}
Request
- Endpoint: POST:
api/v1/users
- Body
(application/json)
Response
- Status:
201: Created
- Body
(application/json)
List Users
This is an admin only route that returns an array of all currently signed up users
Sample JSON structured response:
{
"message": "Data found",
"content": [
{
"id": 1,
"name": "admin",
"email"<EMAIL_ADDRESS>},
{
"id": 2,
"name": "seyi",
"email"<EMAIL_ADDRESS>}
],
"metaData": {
"page": 1,
"pageCount": 1,
"pageSize": 2,
"totalCount": 2
}
}
Request
- Endpoint: GET:
api/v1/users
- Requires: Admin Authentication
Query Parameters
| Parameter | Default | Description |
|---|---|---|
| limit | 10 | Sets the limit. |
| offset | 0 | Sets the offset. |
Response
- Status:
200: OK
- Body
(application/json)
Get User
This route returns the information of the currently signed in user
Response:
{
"name": "seyi",
"email"<EMAIL_ADDRESS>}
Request
- Endpoint: GET:
api/v1/users/:id
- Requires: Authentication
Response
- Status:
200: OK
- Body
(application/json)
Edit User
This route allows the currently logged in user update their email
, name
and password
Request:
{
"name": "new name",
"email": "new email",
"password": "new password"
}
Response:
{
"message": "User updated succesfully",
"updatedUser": {
"name": "new name",
"email": "new name"
}
}
Request
This is an admin only route that deletes an existing user
- Endpoint: PUT:
api/v1/users/:id
- Requires: Authentication
- Body
(application/json)
Response
- Status:
200: OK
- Body
(application/json)
Delete User
Response:
{
"message": "User has been deleted successfully"
}
Request
- Endpoint: DELETE:
api/v1/users/:id
- Requires: Admin Authentication
Response
- Status:
200: OK
- Body
(application/json)
Search Users
Searches for existing users
Response:
{
"message": "User found successfully",
"searchedUser": {
"name": "ade",
"email"<EMAIL_ADDRESS>"id": 1
}
}
Request
- Endpoint: GET:
/search/users
- Requires: Authentication
Query Parameters
| Parameter | Default | Description |
|---|---|---|
| q | "" | Search query. |
Response
- Status:
200: OK
- Body
(application/json)
Documents
Create Document
Creates a new document
Request:
{
"title": "A title",
"content": "some content goes here"
"access": "Public"
}
Response:
{
"message": "Document created succesfully",
"document": {
"title": "my document",
"content": "some content goes here",
"access": "public",
"createdOn": "2017-08-07",
"id": 1
}
}
Request
- Endpoint: POST:
api/v1/documents
Notes
- Document access level is either
public
,private
orrole
. - Only Editors can create
role
access documents
Response
- Status:
201: Created
- Body
(application/json)
All Documents
Returns a json object of all viewable objects
Response:
{
"message": "Data found",
"content": [
{
"title": "my document",
"content": "some content goes here",
"access": "public",
"createdAt": "2017-08-07",
"id": 1,
"User": {
"name": "admin",
"email"<EMAIL_ADDRESS>"id": 1
}
},
{
"title": "title",
"content": "some content goes here",
"access": "public",
"createdAt": "2017-08-07",
"id": 2,
"User": {
"name": "seyi",
"email"<EMAIL_ADDRESS>"id": 3
}
}
],
"metaData": {
"page": 1,
"pageCount": 1,
"pageSize": 2,
"totalCount": 2
}
}
Request
- Endpoint: GET:
api/v1/documents
- Body
(application/json)
Notes
- The response is paginated by default with a limit of 10 and an offset of 0
- To specify pagination add
?={limit}&offset={offset}
to the base url
Response
- Status:
200: Ok
- Body
(application/json)
Get Document
Fetched the document that matches the id in the parameter. Private documents cannot be accessed in this way
Sample JSON structured response:
{
"message": "Document Found succesfully",
"foundDocument": {
"owner": "seyi",
"title": "title",
"content": "some content goes here",
"access": "public",
"createdOn": "2017-08-07",
"id": 2
}
}
Request
- Endpoint: GET:
api/v1/documents/:id
- Requires: Authentication
Response
- Status:
200: OK
- Body
(application/json)
Edit Document
This route allows the owner of a document update it
Request:
{
content: 'some content goes heret',
access: 'role'
}
Response:
{
"message": "Document updated",
"updatedDocument": {
"content": "some content goes here",
"access": "role",
"updatedOn": "Mon, Aug 7th 2017, 12:00:00 am"
}
}
Request
- Endpoint: PUT:
api/v1/documents/:id
- Requires: Authentication
Response
- Status:
200: OK
- Body
(application/json)
Delete Document
This route allows the owner of a document to delete the document specified in the id
Response:
{
"message": "Document has been deleted successfully"
}
Request
- Endpoint: Delete:
api/v1/documents/:id
- Requires: Authentication
Response
- Status:
204: Deleted
- Body
(application/json)
Get User Documents
Returns all documents belonging to the signed in user
Response:
[
{
"title": "title",
"content": "some content goes here",
"access": "public"
},
{
"title": "a new title",
"content": "some new content",
"access": "private"
}
]
Request
- Endpoint: GET:
/api/v1/users/:id/documents
- Requires: Authentication
Response
- Status:
200: OK
- Body
(application/json)
Search Documents
Response:
{
"message": "Document Found",
"searchedDocument": {
"title": "new title",
"content": "new content"
}
}
Request
- Endpoint: GET:
api/v1/search/documents/?q={doctitle}
- Requires: Authentication
Query Parameters
| Parameter | Default | Description |
|---|---|---|
| q | "" | Search query. |
Response
- Status:
200: OK
- Body
(application/json)
Administrators
Change User Role
Request:
{
"role": "3",
}
Response:
{
{
"message": "Role changed",
"user": {
"id": 5,
"name": "seyi",
"email"<EMAIL_ADDRESS>"roleId": "3",
}
}
}
Request
- Endpoint: PUT:
/api/v1/users/:id/role
Notes
Admin
users have a role of1
Users
have a role of2
Editors
have a role of3
Response
- Status:
200: OK
- Body
(application/json)
Errors
The following status codes were implemented in this API :
| Error Code | Meaning |
|---|---|
| 200 | Response Ok |
| 201 | Created |
| 204 | Deleted succesfully |
| 400 | Bad Request |
| 401 | Unauthorized |
| 404 | Not Found |
| 500 | Internal Server Error |


Python (index)
Python (2) - Types and operations
OUTLOOK
Variables
Types
None
bool
Numbers
range
Unicode
Strings in Python 2
Strings in Python 3
Lists
Tuples
Dictionaries
Sets
Homework
Python (index)


Meta-Learning without Memorization
10 Apr 2020Paper link: OpenReview.net
Code link: Google Research Github
Let’s consider how people learn as students. In the morning, we go to school, taking classes and answering questions asked by teachers. In the evening, we go back home, finishing homeworks and checking the answer keys. This daily routine can be considered as solving a task everyday, with task training in class and validation at home. In the end, when graduate from school, we not only obtain specific knowledge, but learn how to learn. Meta-learning is a paradigm in artificial intelligence that mimics such learning procedure. By leveraging experience from previous tasks, the algorithm aims to be able to solve a new task by fast adapting to a few training data. However, to develop the adapting ability, the learner has to avoid a problematic approach which we refer to as the memorization in meta-learning.
TL;DR: In this paper, we aim to answer the main questions: What is the memorization problem in meta-learning? Why does the memorization problem happen? How can we prevent it?
Basics
To set things up, assume there are multiple tasks generated from a task distribution $p(\mathcal{T})$. Each task has some labeled training data $\mathcal{D} = (X,Y)$ and test data $\mathcal{D}^{\star} = (X^{\star},Y^{\star})$. $\mathcal{M}$ represents all the meta-training data and $\mathcal{T}_j$ is a new task. The meta-learner is trained on $\mathcal{M}$, adapted on the new task training data $\mathcal{D}_{j},$ and aims to make good predictions on the new task test inputs $X^{\star}_{j}$. This process can be summarized in a hierarchical graphical model:
Memorization Problem
Let’s come back to the student example at the beginning. The daily study at school can be considered as a task in meta-training, and we assume the student learns to solve one type of math problem every day. After a period, assume all types of required problems have been reviewed several times in class $($like what we once did for an important exam 💆$)$. If a student can remember all problem types, he/she can answer the homework questions of these problem types correctly, without attending the class. Though such seemingly innocuous memorization approach can solve new problems of the known types, however, when the student faces an unseen type of problem, he/she cannot solve it merely based on the memorized knowledge, without learning from new resources.
Let’s consider another illustrative example. Assume each task is a 1D regression on some related data. In the following figures, a meta-learning algorithm is trained to adapt on a few training data, as the red points, and to fit on the validation data, as the blue points, where the dashed line represents a good adapted model
By training on multiple correlated tasks, the model develops a fast adaptation ability, which can generalize to solving tasks that are unseen in the meta-training, as the left figure below. However, we find if the meta-learner is flexible enough, a single model can solve all the training tasks without adapting to the task training data, as the right figure below. In the test-time, when facing a new task, the algorithm will not know how to utilize a few task training data to infer the local parameters and therefore cannot solve the new task.
We call this phenomenon as the $($complete$)$ memorization problem in meta-learning. We formally define it as
\begin{equation} I(\hat{y}^{\star};\mathcal{D} | x^{\star}, \mathcal{M})=0 \end{equation}
which means the predicted label and the task training data are conditionally independent.
Notice the memorization problem is closely related to the task distribution. We find that if the meta-training tasks are mutually exclusive, which means a single model cannot solve all the tasks, the memorization problem will not happen. For example, in the few-shot classification problems, mutually exclusive tasks are created by randomly shuffling the labels across tasks. However, in a wide range of problems the tasks are non-mutually exclusive. Therefore, the memorization problem widely exists and can influence a variety of meta-learning algorithms.
Meta-Regularization
Based on the above analysis and the graphical model, we find that the information that is used to predict the task test labels comes from the meta-traing data $\mathcal{M}$, task training data $\mathcal{D}$ and task test input $x^\star$. Hence, if we can limit the information that flows from $\mathcal{M}$ and $x^\star$, and in the meantime ask for accurate predictions, we can encourage the model to use the information in $\mathcal{D}$ rather than ignoring it. Using the inequalities in information and PAC-Bayes theory, one approach to the meta-regularization we derived is based on the information bottleneck, which regularizes
\begin{equation} D_{KL}(q(z^\star | x^\star, \theta)||r(z^\star )) \end{equation}
The other approach is to regularize
\begin{equation} D_{KL}(q(\theta | \mathcal{M})||r(\theta)) \end{equation}
where $\theta$ are the parameters of an encoder: $x \to z$. Notice we should only regularize the parameters that are not used in the adaptation, which differs from stardand regularizations. Combining the meta-regularization with the objectives in Model Agnostic Meta-Learning $($MAML$)$ and Conditional Neural Process $($CNP$)$, we name our proposed new algorithms as MR-MAML and MR-CNP. We apply them to several datasets where the tasks are non-mutually exclusive, where the standard meta-learning algorithms can fail. The algorithms are tested on a pose prediction dataset where the goal is to predict the orientations of 3D objects by looking at their 2D images. Our methods outperform the compared methods by a large margin
We test on the non-mutually exclusive few-shot classification problems, for which standard meta-learning methods can even give near random predictions in some cases. Our methods provide a remedy.
Takeaways
- Memorization is a prevalent problem in many meta-learning applications and algorithms
- Memorization problem is meta-overfitting at the task level; it differs from standard datapoint-level overfitting. The model can generalize to new points within a training task, but cannot generalize to a new task
- Meta-regularization can effectively control the memorization problem, which expands the meta-learning to the domains that it was once hard to be effective on
- 👉 Keep calm and remain adaptive!
Thanks to the collaborations of Drs. George Tucker, Mingyuan Zhou, Sergey Levine and Chelsea Finn


--- layout: post title: KPN WAPs i-mode date: 2006-06-06 00:00:00 category: mobile ---
KPN WAPs i-mode: "In an odd move KPN has launched a new portal, Mobiel startsite, to make i-mode content accessible for non i-mode customers. KPN subscribers or prepaid users with a WAP enable handset, can access up to fifty i-mode sites and news and "538 ringtones"."


Click here to refresh the page completely
Click here to alert but not refresh the page using Javascript Void() method


Somewhat following on from my previous post about running containers in non-root environments I’ve been spending some more time reading up on Capabilities, so thought it would be worth making some notes.
Linux capabilities have been around in the kernel for some time. The idea is to break up the monolithic root privilege that Linux systems have had, so that smaller more specific privileges can be provided where they’re required. This helps reduce the risk that by compromising a single process on a host an attacker is able to fully compromise it.
One point to make note of is, that capabilities are only needed to carry out privileged actions on a host. If your process only needs to carry out actions that an ordinary user could without the use of sudo, su or setuid root binaries, then your process doesn’t need any capabilities assigned to it.
To provide a concrete example, take the ping
program which ships with most Linux disitributions. Traditionally this program has been setuid root due to the fact that it needs to send raw network packets and this privilege is not availble to ordinary users. With a capability aware system this can be broken down and only the CAP_NET_RAW privilege can be assigned to the file. This means that an attacker who was able to compromise the ping binary, would only get a small additional level of privilege and not full access to the host, as might have been possible when it was setuid root.
So how do we actually manipulate capabilites on a Linux system? The most basic way of handing this (without writing custom code) is to use the getcap
and setcap
binaries which come with the libcap2-bin package on debian derived systems.
If you use getcap on a file which has capabilities, you’ll see something like this
/usr/bin/arping = cap_net_raw+ep
We can see here that the arping file has cap_net_raw with +ep
at the end of it, so what does that mean. The e here refers to the effective capability of the file and the p to the permitted capability. Effectively for file capabilities the effective flag is needed where the binary isn’t “capability aware” i.e. it’s not written with capabilities in mind (which is usually the case). For practical purposes if you’re assigning capabilities to files, you’ll use +ep
most of the time.
So if you want to assign a capability, for example to apply cap_net_raw to an nmap binary
setcap cap_net_raw+ep /usr/bin/nmap
It’s important to note that you can’t set capabilities on symlinks, it has to be the binary, and also you can’t set capabilities on shell scripts (well unless you have a super-recent kernel)
If you look at capability sets for files and processes, you’ll run across two additional terms which bear looking at, Inheritable and Bounded.
Inheritable capabilites are capabilites that can be passed from one program to another.
Bounded capabilities are, to quote the Man page for capabilities
The capability bounding set acts as a limiting superset for the capabilities that a thread can add to its inheritable set using capset(2).
So they restrict which capabilities can be inherited by a process.
This is all well and good, but how do we audit capabilities?
there’s a number of ways of reviewing what capabilities a process or file has got. From a low-level perspective, we can review the contents of /proc/[pid]/status. This will contain some information that looks like this :-
CapInh:<PHONE_NUMBER>000000
CapPrm:<PHONE_NUMBER>000000
CapEff:<PHONE_NUMBER>000000
CapBnd: 0000003fffffffff
CapAmb:<PHONE_NUMBER>000000
This set was for a user level process (using the command cat /proc/self/status
). As you can see the CapPrm and CapEff are both all zero’s indicating that I don’t have any capabilities and assigned.
If I then switch to a root user using sudo bash
and run the same command, I get the following
CapInh:<PHONE_NUMBER>000000
CapPrm: 0000003fffffffff
CapEff: 0000003fffffffff
CapBnd: 0000003fffffffff
which is quite the difference, here CapPrm and CapEff have a lot more content as I’m a privileged user.
If we try the same in a Docker process using the command docker run alpine:latest cat /proc/self/status
we get
CapInh: 00000000a80425fb
CapPrm: 00000000a80425fb
CapEff: 00000000a80425fb
CapBnd: 00000000a80425fb
which is quite different. In this container we were running as root, so you might have guessed that we’d have the same permissions as we did in the root shell before. However as Docker limits the available default permissions we don’t get as much.
Of course these long hex strings aren’t exactly the most friendly way of viewing capabilities. Luckily there are ways of making this a bit more readable. if we use capsh
(which comes with libcap2-bin on debian derived systems) we can work out what’s meant here.
Running capsh --decode=0000003fffffffff
returns
0x0000003fffffffff=cap_chown,cap_dac_override,cap_dac_read_search,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_linux_immutable,cap_net_bind_service,cap_net_broadcast,cap_net_admin,cap_net_raw,cap_ipc_lock,cap_ipc_owner,cap_sys_module,cap_sys_rawio,cap_sys_chroot,cap_sys_ptrace,cap_sys_pacct,cap_sys_admin,cap_sys_boot,cap_sys_nice,cap_sys_resource,cap_sys_time,cap_sys_tty_config,cap_mknod,cap_lease,cap_audit_write,cap_audit_control,cap_setfcap,cap_mac_override,cap_mac_admin,cap_syslog,cap_wake_alarm,cap_block_suspend,37
So that shows that our root shell run outside basically had all the capabilities. If we run capsh --decode=00000000a80425fb
we can see what Docker provides by default
0x00000000a80425fb=cap_chown,cap_dac_override,cap_fowner,cap_fsetid,cap_kill,cap_setgid,cap_setuid,cap_setpcap,cap_net_bind_service,cap_net_raw,cap_sys_chroot,cap_mknod,cap_audit_write,cap_setfcap
which corresponds to the list in the source code.
So which of these capabilities are a concern from a security perspective? Well to an extent that’s going to depend on how you’re using them. However there are some good starting points to look at, firstly there’s this post from the grsecurity forum that goes into the risks of allowing various capabilities. You can also look at the default list of capabilities that Docker allows (link above), as the ones they block are things that have been determined as dangerous in the context of containers.
There are some other utilities which are handy for doing things like auditing capabilities. the libcap-ng-utils package has the very handy filecap
and pscap
programs which can be used to review capapbilties on all files and all processes on a system by default. There’s also captest
which will review capabilities in the context of the current process.
Also if you’re running containers and want a nice quick way to assess capabilities amongst other things, you could use Jessie Frazelle’s amicontained
So what has all this to do with Containers? Well it’s worth noting what was mentioned early in this post which is, if you have a container which will run as a non-root user and which has no setuid or setgid root prgrams in it, you should be good to drop all capabilities. This adds another layer of hardening to the container, which can be helpful in preventing container breakout issues.
If you’re running with root containers, then it’s well worth reviewing the default list of capabilities that is provided by your container runtime an ensuring that you’re happy that these are needed.
Specifically there are ones like CAP_NET_RAW in the default docker set which could be dangerous (see here for more details)
There are some gotcha’s to be aware of when using capabilities. First up is that, to use file capabilities, the filesystem you’re running from needs have extended attribute (xattr) support. A notable exception here is some versions of aufs that ship with some versions Debian and Ubuntu. This can impact Docker installs, as they’ll use aufs by default.
Another one is that where you’re manipulating files you need to make sure that the tools you’re using understand capabilities. For example when backing up files with tar, you need to use the following switches to make it all work.
--xattrs Enable extended attributes support
--xattrs-exclude=MASK specify the exclude pattern for xattr keys
--xattrs-include=MASK specify the include pattern for xattr keys
In practice for tar you’ll likely want to use --xattrs
and --xatttrs-include=security.capability
to make backups of files with capabilities.


My name is Grace Hopper
I work in the NAVY as a programmer
For fun, I research how to write new machine programs
My favorite movie is "Hamlet"
My favorite type of music is jazz
In ten years I hope to be creating more complex programs that help the Navy
Here is a link to my Wikipedia page


The Voyages of Doctor Dolittle
by Hugh Lofting
Part 3, Chapter 6: The Bed-Maker of Monteverde
Additional Information
- Year Published: 1922
- Language: English
- Country of Origin: England
- Source: Lofting, H. (1922). The Voyages of Doctor Dolittle. London, England: Lippincott Publishing.
-
Readability:
- Flesch–Kincaid Level: 4.2
- Word Count: 747
- Genre: Fantasy
- Keywords: 20th century literature, british literature, children's literature
- ✎ Cite This
Downloads
We remained three days in the Capa Blanca Islands. There were two reasons why we stayed there so long when we were really in such a hurry to get away. One was the shortage in our provisions caused by the able seaman's enormous appetite. When we came to go over the stores and make a list, we found that he had eaten a whole lot of other things besides the beef. And having no money, we were sorely puzzled how to buy more. The Doctor went through his trunk to see if there was anything he could sell. But the only thing he could find was an old watch with the hands broken and the back dented in; and we decided this would not bring us in enough money to buy much more than a pound of tea. Bumpo suggested that he sing comic songs in the streets which he had learned in Jolliginki. But the Doctor said he did not think that the islanders would care for African music.
The other thing that kept us was the bullfight. In these islands, which belonged to Spain, they had bullfights every Sunday. It was on a Friday that we arrived there; and after we had got rid of the able seaman we took a walk through the town.
It was a very funny little town, quite different from any that I had ever seen. The streets were all twisty and winding and so narrow that a wagon could only just pass along them. The houses overhung at the top and came so close together that people in the attics could lean out of the windows and shake hands with their neighbors on the opposite side of the street. The Doctor told us the town was very, very old. It was called Monteverde.
As we had no money of course we did not go to a hotel or anything like that. But on the second evening when we were passing by a bed-maker's shop we noticed several beds, which the man had made, standing on the pavement outside. The Doctor started chatting in Spanish to the bed-maker who was sitting at his door whistling to a parrot in a cage. The Doctor and the bed-maker got very friendly talking about birds and things. And as it grew near to supper-time the man asked us to stop and sup with him.
This of course we were very glad to do. And after the meal was over (very nice dishes they were, mostly cooked in olive-oil—I particularly liked the fried bananas) we sat outside on the pavement again and went on talking far into the night.
At last when we got up, to go back to our ship, this very nice shopkeeper wouldn't hear of our going away on any account. He said the streets down by the harbor were very badly lighted and there was no moon. We would surely get lost. He invited us to spend the night with him and go back to our ship in the morning.
Well, we finally agreed; and as our good friend had no spare bedrooms, the three of us, the Doctor, Bumpo and I, slept on the beds set out for sale on the pavement before the shop. The night was so hot we needed no coverings. It was great fun to fall asleep out of doors like this, watching the people walking to and fro and the gay life of the streets. It seemed to me that Spanish people never went to bed at all. Late as it was, all the little restaurants and cafes around us were wide open, with customers drinking coffee and chatting merrily at the small tables outside. The sound of a guitar strumming softly in the distance mingled with the clatter of chinaware and the babble of voices.
Somehow it made me think of my mother and father far away in Puddleby, with their regular habits, the evening practise on the flute and the rest—doing the same thing every day. I felt sort of sorry for them in a way, because they missed the fun of this traveling life, where we were doing something new all the time—even sleeping differently. But I suppose if they had been invited to go to bed on a pavement in front of a shop they wouldn't have cared for the idea at all.


SockPairer
Click and drag like-coloured socks to pair them up.
Make Jerry Seinfeld's dream a reality.


{% extends "multifactor/base.html" %} {% block card_title %}Multi-Factor Authentication{% endblock %} {% block content %}
You are logged in but you need to verify one of your secondary factors to continue. Which factor would you like to authenticate with?
{% for link, label, factors in methods %} {{label}} {{factors}} {% endfor %} {% if fallbacks %}


UEFA confirm draw will decide home advantage for Euro 2020 play-off finals
by James CoxUEFA have revealed that a draw will decide which team plays at home in the Euro 2020 play-off finals.
The draw takes place in Switzerland on Friday and it will confirm if Ireland will play at the Aviva Stadium, Windsor Park or in Bosnia & Herzegovina, should they get past Slovakia in the play-off semi-final.
Wales' 2-0 victory over Hungary last night confirmed Ireland will face Slovakia, with that game set to take place on Thursday, March 26 at 7.45pm.
Slovakia must declare the home venue within a month, they've played all their recent games in Trnava but the reopened stadium in Bratislava could also play host to the game.
The venue must be confirmed before December 20.
If Ireland beat Slovakia, they will face the winner of Bosnia v Northern Ireland on Thursday, March 31, for a place at Euro 2020.
UEFA have also confirmed that the draw for the group stages of Euro 2020 will take place on Saturday, November 30.
Ireland will be in Group E with Spain if they qualify due to their status as tournament hosts.
The seeds have been confirmed for the main draw, meaning Ireland would play Spain along with one team from France, Poland, Switzerland or Croatia.
The other team in the group would be either Portugal, Turkey, Austria, Sweden or the Czech Republic.
Euro 2020 play-off round fixtures:
Path A
Iceland v Hungary/Romania
Bulgaria/Israel v Israel/Hungary
Path B
Bosnia and Herzegovina v Northern Ireland
Slovakia vs. Republic of Ireland
Path C
Scotland v Bulgaria/Israel/Romania/Hungary
Norway v Serbia
Path D
Georgia v Belarus
North Macedonia v Kosovo
Euro 2020 Pots:
Pot 1
- Belgium
- Italy (hosts)
- England (hosts)
- Germany (hosts)
- Spain (hosts)
- Ukraine
Pot 2
- France
- Poland
- Switzerland
- Croatia
- Netherlands (hosts)
- Russia (hosts)
Pot 3
- Portugal
- Turkey
- Denmark (hosts)
- Austria
- Sweden
- Czech Republic
Pot 4
- Wales
- Finland
- Winner play-off Path A
- Winner play-off Path B (potentially Ireland or Northern Ireland)
- Winner play-off Path C
- Winner play-off Path D


| Top |
| GtkContainer * | align-widget | Read / Write |
| GtkArrowType | direction | Read / Write |
| GMenuModel * | menu-model | Read / Write |
| GtkPopover * | popover | Read / Write |
| GtkMenu * | popup | Read / Write |
| gboolean | use-popover | Read / Write |
GObject ╰── GInitiallyUnowned ╰── GtkWidget ╰── GtkContainer ╰── GtkBin ╰── GtkButton ╰── GtkToggleButton ╰── GtkMenuButton
GtkMenuButton implements AtkImplementorIface, GtkBuildable, GtkActionable and GtkActivatable.
The GtkMenuButton widget is used to display a popup when clicked on. This popup can be provided either as a GtkMenu, a GtkPopover or an abstract GMenuModel.
The GtkMenuButton widget can hold any valid child widget. That is, it can hold almost any other standard GtkWidget. The most commonly used child is GtkImage. If no widget is explicitely added to the GtkMenuButton, a GtkImage is automatically created, using an arrow image oriented according to “direction” or the generic "view-context-menu" icon if the direction is not set.
The positioning of the popup is determined by the “direction” property of the menu button.
For menus, the “halign” and “valign” properties of the
menu are also taken into account. For example, when the direction is
GTK_ARROW_DOWN
and the horizontal alignment is GTK_ALIGN_START
, the
menu will be positioned below the button, with the starting edge
(depending on the text direction) of the menu aligned with the starting
edge of the button. If there is not enough space below the button, the
menu is popped up above the button instead. If the alignment would move
part of the menu offscreen, it is “pushed in”.
GtkMenuButton has a single CSS node with name button. To differentiate it from a plain GtkButton, it gets the .popup style class.
GtkWidget *
gtk_menu_button_new (void
);
Creates a new GtkMenuButton widget with downwards-pointing arrow as the only child. You can replace the child widget with another GtkWidget should you wish to.
Since: 3.6
void gtk_menu_button_set_popup (GtkMenuButton *menu_button
,GtkWidget *menu
);
Sets the GtkMenu that will be popped up when the button is clicked,
or NULL
to disable the button. If “menu-model” or
“popover” are set, they will be set to NULL
.
Since: 3.6
GtkMenu *
gtk_menu_button_get_popup (GtkMenuButton *menu_button
);
Returns the GtkMenu that pops out of the button.
If the button does not use a GtkMenu, this function
returns NULL
.
Since: 3.6
void gtk_menu_button_set_popover (GtkMenuButton *menu_button
,GtkWidget *popover
);
Sets the GtkPopover that will be popped up when the button is
clicked, or NULL
to disable the button. If “menu-model”
or “popup” are set, they will be set to NULL
.
Since: 3.12
GtkPopover *
gtk_menu_button_get_popover (GtkMenuButton *menu_button
);
Returns the GtkPopover that pops out of the button.
If the button is not using a GtkPopover, this function
returns NULL
.
Since: 3.12
void gtk_menu_button_set_menu_model (GtkMenuButton *menu_button
,GMenuModel *menu_model
);
Sets the GMenuModel from which the popup will be constructed,
or NULL
to disable the button.
Depending on the value of “use-popover”, either a
GtkMenu will be created with gtk_menu_new_from_model()
, or a
GtkPopover with gtk_popover_new_from_model()
. In either case,
actions will be connected as documented for these functions.
If “popup” or “popover” are already set, their content will be lost and replaced by the newly created popup.
Since: 3.6
GMenuModel *
gtk_menu_button_get_menu_model (GtkMenuButton *menu_button
);
Returns the GMenuModel used to generate the popup.
Since: 3.6
void gtk_menu_button_set_use_popover (GtkMenuButton *menu_button
,gboolean use_popover
);
Sets whether to construct a GtkPopover instead of GtkMenu
when gtk_menu_button_set_menu_model()
is called. Note that
this property is only consulted when a new menu model is set.
Since: 3.12
gboolean
gtk_menu_button_get_use_popover (GtkMenuButton *menu_button
);
Returns whether a GtkPopover or a GtkMenu will be constructed from the menu model.
Since: 3.12
void gtk_menu_button_set_direction (GtkMenuButton *menu_button
,GtkArrowType direction
);
Sets the direction in which the popup will be popped up, as well as changing the arrow’s direction. The child will not be changed to an arrow if it was customized.
If the does not fit in the available space in the given direction, GTK+ will its best to keep it inside the screen and fully visible.
If you pass GTK_ARROW_NONE
for a direction
, the popup will behave
as if you passed GTK_ARROW_DOWN
(although you won’t see any arrows).
Since: 3.6
GtkArrowType
gtk_menu_button_get_direction (GtkMenuButton *menu_button
);
Returns the direction the popup will be pointing at when popped up.
Since: 3.6
void gtk_menu_button_set_align_widget (GtkMenuButton *menu_button
,GtkWidget *align_widget
);
Sets the GtkWidget to use to line the menu with when popped up.
Note that the align_widget
must contain the GtkMenuButton itself.
Setting it to NULL
means that the menu will be aligned with the
button itself.
Note that this property is only used with menus currently, and not for popovers.
Since: 3.6
GtkWidget *
gtk_menu_button_get_align_widget (GtkMenuButton *menu_button
);
Returns the parent GtkWidget to use to line up with menu.
Since: 3.6
“align-widget”
property“align-widget” GtkContainer *
The GtkWidget to use to align the menu with.
Flags: Read / Write
Since: 3.6
“direction”
property“direction” GtkArrowType
The GtkArrowType representing the direction in which the menu or popover will be popped out.
Flags: Read / Write
Default value: GTK_ARROW_DOWN
Since: 3.6
“menu-model”
property“menu-model” GMenuModel *
The GMenuModel from which the popup will be created. Depending on the “use-popover” property, that may be a menu or a popover.
See gtk_menu_button_set_menu_model()
for the interaction with the
“popup” property.
Flags: Read / Write
Since: 3.6
“popover”
property“popover” GtkPopover *
The GtkPopover that will be popped up when the button is clicked.
Flags: Read / Write
Since: 3.12
“popup”
property“popup” GtkMenu *
The GtkMenu that will be popped up when the button is clicked.
Flags: Read / Write
Since: 3.6
“use-popover”
property“use-popover” gboolean
Whether to construct a GtkPopover from the menu model, or a GtkMenu.
Flags: Read / Write
Default value: TRUE
Since: 3.12


Anime
Attributes
Reset Input
Create
Update
Delete
Clear Database
Attributes must be entered in the following format:
{"Status": "[Enter Status]", "Rating": [Enter rating from 1-10, 10 being the best Anime], "Episodes": [Enter number of episodes]}
Example: {"Status": "Completed", "Rating": 10, "Episodes": 26}
Anime
Status
Rating
Episodes


NOTE: if the camera is already in use for streaming by another application/client, applying the resolution & format will not have any effect (until all the streaming sessions have been closed).


---
layout: post
title: links for 2007-03-06
date: 2007-03-06 00:00:00
---
-
"Yes, there are risks outside our homes. But there are also risks in raising children under virtual protective house arrest: threats to their independent judgment and value of place, to their ability to feel awe and wonder..."
-
"Touch carries meaning and this changes according to context, situation and culture. The project explores these contexts through social, cultural and ethnographic research."


Photodiary
The perfect weekend getaway
Minimo is the largest producer of quality content, founded in 2001. The company brings together seven production enterprises that create content throughout Europe and America. Distribution network is represented in 36 countries of the world. The production complex of the Minimo company provides a high-quality and professional approach to each customer. Minimo's distribution office consists of 250 people. The company’s capacities allow to fulfill more than 100 thousand. orders per year. Content creation uses only the latest generation application certification and technology.


jQuery Crash Course | Effects And Animations
Fade Out
Fade In
Fade Toggle
Slide Up
SLide Down
Slide Toggle
Slide Stop
Slide Up/Down
Hello World
Move Left
Move Right
Move Randomly
Move Around
I can move


| Modifier and Type | Method and Description |
|---|---|
SDVariable |
SDMath.firstIndex(SDVariable in,
Condition condition,
boolean keepDims,
int... dimensions)
First index reduction operation.
|
SDVariable |
SDMath.firstIndex(SDVariable in,
Condition condition,
int... dimensions)
First index reduction operation.
|
SDVariable |
SDMath.firstIndex(String name,
SDVariable in,
Condition condition,
boolean keepDims,
int... dimensions)
First index reduction operation.
|
SDVariable |
SDMath.firstIndex(String name,
SDVariable in,
Condition condition,
int... dimensions)
First index reduction operation.
|
SDVariable |
SDMath.lastIndex(SDVariable in,
Condition condition,
boolean keepDims,
int... dimensions)
Last index reduction operation.
|
SDVariable |
SDMath.lastIndex(SDVariable in,
Condition condition,
int... dimensions)
Last index reduction operation.
|
SDVariable |
SDMath.lastIndex(String name,
SDVariable in,
Condition condition,
boolean keepDims,
int... dimensions)
Last index reduction operation.
|
SDVariable |
SDMath.lastIndex(String name,
SDVariable in,
Condition condition,
int... dimensions)
Last index reduction operation.
|
SDVariable |
SDBaseOps.matchCondition(SDVariable in,
Condition condition)
Returns a boolean mask of equal shape to the input, where the condition is satisfied - value 1 where satisfied, 0 otherwise
|
SDVariable |
SDBaseOps.matchCondition(String name,
SDVariable in,
Condition condition)
Returns a boolean mask of equal shape to the input, where the condition is satisfied - value 1 where satisfied, 0 otherwise
|
SDVariable |
SDBaseOps.matchConditionCount(SDVariable in,
Condition condition)
Returns a count of the number of elements that satisfy the condition
|
SDVariable |
SDBaseOps.matchConditionCount(SDVariable in,
Condition condition,
boolean keepDim,
int... dimensions)
Returns a count of the number of elements that satisfy the condition (for each slice along the specified dimensions)
Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1. |
SDVariable |
SDBaseOps.matchConditionCount(SDVariable in,
Condition condition,
int... dimensions)
Returns a count of the number of elements that satisfy the condition (for each slice along the specified dimensions)
Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1. |
SDVariable |
SDBaseOps.matchConditionCount(String name,
SDVariable in,
Condition condition)
Returns a count of the number of elements that satisfy the condition
|
SDVariable |
SDBaseOps.matchConditionCount(String name,
SDVariable in,
Condition condition,
boolean keepDim,
int... dimensions)
Returns a count of the number of elements that satisfy the condition (for each slice along the specified dimensions)
Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1. |
SDVariable |
SDBaseOps.matchConditionCount(String name,
SDVariable in,
Condition condition,
int... dimensions)
Returns a count of the number of elements that satisfy the condition (for each slice along the specified dimensions)
Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1. |
SDVariable |
SDBaseOps.replaceWhere(SDVariable update,
double value,
Condition condition)
Element-wise replace where condition:
out[i] = value if condition(update[i]) is satisfied, or out[i] = update[i] if condition(update[i]) is NOT satisfied |
SDVariable |
SDBaseOps.replaceWhere(SDVariable update,
SDVariable from,
Condition condition)
Element-wise replace where condition:
out[i] = from[i] if condition(update[i]) is satisfied, or out[i] = update[i] if condition(update[i]) is NOT satisfied |
SDVariable |
SDBaseOps.replaceWhere(String name,
SDVariable update,
double value,
Condition condition)
Element-wise replace where condition:
out[i] = value if condition(update[i]) is satisfied, or out[i] = update[i] if condition(update[i]) is NOT satisfied |
SDVariable |
SDBaseOps.replaceWhere(String name,
SDVariable update,
SDVariable from,
Condition condition)
Element-wise replace where condition:
out[i] = from[i] if condition(update[i]) is satisfied, or out[i] = update[i] if condition(update[i]) is NOT satisfied |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
BaseNDArray.assignIf(INDArray arr,
Condition condition) |
INDArray |
INDArray.assignIf(INDArray arr,
Condition condition)
Assign all elements from given ndarray that are matching given condition,
ndarray to this ndarray
|
INDArray |
BaseNDArray.cond(Condition condition) |
INDArray |
INDArray.cond(Condition condition)
Returns a binary INDArray with value 'true' if the element matches the specified condition and 'false' otherwise
|
INDArray |
BaseNDArray.getWhere(INDArray comp,
Condition condition) |
INDArray |
INDArray.getWhere(INDArray comp,
Condition condition)
Boolean indexing:
Return the element if it fulfills the condition in
result array
|
INDArray |
BaseNDArray.getWhere(Number comp,
Condition condition) |
INDArray |
INDArray.getWhere(Number comp,
Condition condition)
Boolean indexing:
Return the element if it fulfills the condition in
result array
|
INDArray |
BaseNDArray.match(INDArray comp,
Condition condition) |
INDArray |
INDArray.match(INDArray comp,
Condition condition)
Return a mask on whether each element matches the given condition
|
INDArray |
BaseNDArray.match(Number comp,
Condition condition) |
INDArray |
INDArray.match(Number comp,
Condition condition)
Returns a mask
|
INDArray |
BaseNDArray.putWhere(INDArray comp,
INDArray put,
Condition condition) |
INDArray |
INDArray.putWhere(INDArray comp,
INDArray put,
Condition condition)
Assign the element according to the comparison array
|
INDArray |
BaseNDArray.putWhere(Number comp,
INDArray put,
Condition condition) |
INDArray |
INDArray.putWhere(Number comp,
INDArray put,
Condition condition)
Assign the element according to the comparison array
|
INDArray |
BaseNDArray.putWhere(Number comp,
Number put,
Condition condition) |
INDArray |
INDArray.putWhere(Number comp,
Number put,
Condition condition)
Assign the element according to the comparison array
|
INDArray |
BaseNDArray.replaceWhere(INDArray arr,
Condition condition) |
INDArray |
INDArray.replaceWhere(INDArray arr,
Condition condition)
Replaces all elements in this ndarray that are matching give condition, with corresponding elements from given array
|
Number |
BaseNDArray.scan(Condition condition) |
Number |
INDArray.scan(Condition condition)
This method takes boolean condition, and returns number of elements matching this condition
|
| Modifier and Type | Field and Description |
|---|---|
protected Condition |
FirstIndex.condition |
protected Condition |
LastIndex.condition |
| Constructor and Description |
|---|
FirstIndex(INDArray x,
boolean keepDims,
@NonNull Condition condition,
int... dimension) |
FirstIndex(INDArray x,
@NonNull Condition condition,
boolean keepDims,
int... dimension) |
FirstIndex(INDArray x,
@NonNull Condition condition,
double eps,
int... dimension) |
FirstIndex(INDArray x,
@NonNull Condition condition,
int... dimension) |
FirstIndex(SameDiff sameDiff,
SDVariable i_v,
boolean keepDims,
Condition condition,
int... dimensions) |
FirstIndex(SameDiff sameDiff,
SDVariable i_v,
Condition condition,
boolean keepDims,
int... dimensions) |
LastIndex(INDArray in,
boolean keepDim,
Condition condition,
int... dimensions) |
LastIndex(INDArray x,
@NonNull Condition condition,
boolean keepDim,
int... dimensions) |
LastIndex(INDArray x,
@NonNull Condition condition,
double eps,
int... dimensions) |
LastIndex(INDArray x,
@NonNull Condition condition,
int... dimensions) |
LastIndex(SameDiff sameDiff,
SDVariable i_v,
boolean keepDims,
Condition condition,
int... dimensions) |
LastIndex(SameDiff sameDiff,
SDVariable i_v,
Condition condition,
boolean keepDims,
int... dimensions) |
LastIndex(SameDiff sameDiff,
SDVariable x,
@NonNull Condition condition,
int... dimensions) |
| Constructor and Description |
|---|
MatchCondition(INDArray x,
Condition condition,
boolean keepDims,
int... dimensions) |
MatchCondition(INDArray x,
Condition condition,
int... dimensions) |
MatchCondition(INDArray x,
double eps,
Condition condition,
int... dimensions) |
MatchCondition(SameDiff sameDiff,
SDVariable in,
Condition condition) |
MatchCondition(SameDiff sameDiff,
SDVariable in,
Condition condition,
boolean keepDims,
int... dimensions) |
| Constructor and Description |
|---|
MatchConditionTransform(INDArray x,
@NonNull Condition condition) |
MatchConditionTransform(INDArray x,
double eps,
@NonNull Condition condition) |
MatchConditionTransform(@NonNull INDArray x,
@NonNull INDArray z,
@NonNull Condition condition) |
MatchConditionTransform(INDArray x,
INDArray z,
double eps,
@NonNull Condition condition) |
MatchConditionTransform(@NonNull INDArray x,
@NonNull INDArray y,
@NonNull INDArray z,
@NonNull Condition condition) |
MatchConditionTransform(SameDiff sameDiff,
SDVariable in,
Condition condition) |
| Constructor and Description |
|---|
CompareAndReplace(INDArray x,
INDArray y,
Condition condition)
With this constructor, op will check each X element against given Condition, and if condition met, element Z will be set to Y value, and X otherwise
PLEASE NOTE: X will be modified inplace.
|
CompareAndReplace(INDArray x,
INDArray y,
INDArray z,
Condition condition)
With this constructor, op will check each X element against given Condition, and if condition met, element Z will be set to Y value, and X otherwise
Pseudocode:
z[i] = condition(x[i]) ?
|
CompareAndReplace(SameDiff sameDiff,
SDVariable to,
SDVariable from,
Condition condition) |
CompareAndSet(INDArray x,
double set,
Condition condition)
With this constructor, op will check each X element against given Condition, and if condition met, element will be replaced with Set value
Pseudocode:
z[i] = condition(x[i]) ?
|
CompareAndSet(INDArray x,
double compare,
double set,
double eps,
Condition condition) |
CompareAndSet(INDArray x,
INDArray y,
Condition condition)
With this constructor, op will check each Y element against given Condition, and if condition met, element Z will be set to Y value, and X otherwise
PLEASE NOTE: X will be modified inplace.
|
CompareAndSet(INDArray x,
INDArray z,
double set,
Condition condition)
With this constructor, op will check each X element against given Condition, and if condition met, element will be replaced with Set value
Pseudocode:
z[i] = condition(x[i]) ?
|
CompareAndSet(INDArray x,
INDArray y,
INDArray z,
Condition condition)
With this constructor, op will check each Y element against given Condition, and if condition met, element Z will be set to Y value, and X otherwise
Pseudocode:
z[i] = condition(y[i]) ?
|
CompareAndSet(SameDiff sameDiff,
SDVariable to,
Number set,
Condition condition) |
| Constructor and Description |
|---|
Choose(INDArray[] inputs,
Condition condition) |
Choose(INDArray[] inputs,
List<Integer> iArgs,
List<Double> tArgs,
Condition condition)
Note that iArgs (integer arguments) and tArgs(double/float arguments)
may end up being used under the following conditions:
scalar operations (if a scalar is specified the you do not need to specify an ndarray)
otherwise, if an ndarray is needed as a second input then put it in the inputs
Usually, you only need 1 input (the equivalent of the array you're trying to do indexing on)
|
Choose(SameDiff sameDiff,
SDVariable[] args,
Condition condition) |
Choose(String opName,
INDArray[] inputs,
Condition condition) |
| Modifier and Type | Method and Description |
|---|---|
INDArray |
NDMath.firstIndex(INDArray in,
Condition condition,
boolean keepDims,
int... dimensions)
First index reduction operation.
|
INDArray |
NDMath.firstIndex(INDArray in,
Condition condition,
int... dimensions)
First index reduction operation.
|
INDArray |
NDMath.lastIndex(INDArray in,
Condition condition,
boolean keepDims,
int... dimensions)
Last index reduction operation.
|
INDArray |
NDMath.lastIndex(INDArray in,
Condition condition,
int... dimensions)
Last index reduction operation.
|
INDArray |
NDBase.matchCondition(INDArray in,
Condition condition)
Returns a boolean mask of equal shape to the input, where the condition is satisfied - value 1 where satisfied, 0 otherwise
|
INDArray |
NDBase.matchConditionCount(INDArray in,
Condition condition)
Returns a count of the number of elements that satisfy the condition
|
INDArray |
NDBase.matchConditionCount(INDArray in,
Condition condition,
boolean keepDim,
int... dimensions)
Returns a count of the number of elements that satisfy the condition (for each slice along the specified dimensions)
Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1. |
INDArray |
NDBase.matchConditionCount(INDArray in,
Condition condition,
int... dimensions)
Returns a count of the number of elements that satisfy the condition (for each slice along the specified dimensions)
Note that if keepDims = true, the output variable has the same rank as the input variable, with the reduced dimensions having size 1. |
INDArray |
NDBase.replaceWhere(INDArray update,
double value,
Condition condition)
Element-wise replace where condition:
out[i] = value if condition(update[i]) is satisfied, or out[i] = update[i] if condition(update[i]) is NOT satisfied |
INDArray |
NDBase.replaceWhere(INDArray update,
INDArray from,
Condition condition)
Element-wise replace where condition:
out[i] = from[i] if condition(update[i]) is satisfied, or out[i] = update[i] if condition(update[i]) is NOT satisfied |
| Modifier and Type | Method and Description |
|---|---|
static boolean |
BooleanIndexing.and(INDArray n,
Condition cond)
And over the whole ndarray given some condition
|
static boolean[] |
BooleanIndexing.and(INDArray n,
Condition condition,
int... dimension)
And over the whole ndarray given some condition, with respect to dimensions
|
static void |
BooleanIndexing.assignIf(@NonNull INDArray to,
@NonNull INDArray from,
@NonNull Condition condition)
This method does element-wise comparison
for 2 equal-sized matrices, for each element that matches Condition.
|
static INDArray |
BooleanIndexing.chooseFrom(@NonNull INDArray[] input,
@NonNull Condition condition)
Choose from the inputs based on the given condition.
|
static INDArray |
BooleanIndexing.chooseFrom(@NonNull INDArray[] input,
@NonNull List<Double> tArgs,
@NonNull List<Integer> iArgs,
@NonNull Condition condition)
Choose from the inputs based on the given condition.
|
static INDArray |
BooleanIndexing.firstIndex(INDArray array,
Condition condition)
This method returns first index matching given condition
PLEASE NOTE: This method will return -1 value if condition wasn't met
|
static INDArray |
BooleanIndexing.firstIndex(INDArray array,
Condition condition,
int... dimension)
This method returns first index matching given condition along given dimensions
PLEASE NOTE: This method will return -1 values for missing conditions
|
static INDArray |
BooleanIndexing.lastIndex(INDArray array,
Condition condition)
This method returns last index matching given condition
PLEASE NOTE: This method will return -1 value if condition wasn't met
|
static INDArray |
BooleanIndexing.lastIndex(INDArray array,
Condition condition,
int... dimension)
This method returns first index matching given condition along given dimensions
PLEASE NOTE: This method will return -1 values for missing conditions
|
static boolean |
BooleanIndexing.or(INDArray n,
Condition cond)
Or over the whole ndarray given some condition
|
static boolean[] |
BooleanIndexing.or(INDArray n,
Condition condition,
int... dimension)
Or over the whole ndarray given some condition, with respect to dimensions
|
static void |
BooleanIndexing.replaceWhere(@NonNull INDArray to,
@NonNull INDArray from,
@NonNull Condition condition)
This method does element-wise comparison for 2 equal-sized matrices, for each element that matches Condition
|
static void |
BooleanIndexing.replaceWhere(@NonNull INDArray to,
@NonNull Number set,
@NonNull Condition condition)
This method does element-wise assessing for 2 equal-sized matrices, for each element that matches Condition
|
| Modifier and Type | Class and Description |
|---|---|
class |
AbsValueGreaterOrEqualsThan
Boolean condition on absolute value: abs(x) >= value
|
class |
AbsValueGreaterThan
Boolean condition on absolute value: abs(x) > value
|
class |
AbsValueLessOrEqualsThan
Boolean condition on absolute value: abs(x) <= value
|
class |
AbsValueLessThan
Boolean condition on absolute value: abs(x) < value
|
class |
And
Created by agibsonccc on 10/9/14.
|
class |
BaseCondition
Created by agibsonccc on 10/8/14.
|
class |
ConditionEquals
Returns true when all of the conditions equal each other
|
class |
EpsilonEquals
Created by agibsonccc on 10/8/14.
|
class |
EpsilonNotEquals
Created by agibsonccc on 10/8/14.
|
class |
EqualsCondition
Created by agibsonccc on 10/8/14.
|
class |
GreaterThan
Created by agibsonccc on 10/8/14.
|
class |
GreaterThanOrEqual
Created by agibsonccc on 10/8/14.
|
class |
IsFinite
Created by agibsonccc on 10/8/14.
|
class |
IsInfinite
Created by agibsonccc on 10/8/14.
|
class |
IsNaN
Condition for whether an element is NaN
|
class |
LessThan
Created by agibsonccc on 10/8/14.
|
class |
LessThanOrEqual
Created by agibsonccc on 10/8/14.
|
class |
Not
Created by agibsonccc on 10/9/14.
|
class |
NotEqualsCondition
Created by agibsonccc on 10/8/14.
|
class |
NotFinite
Created by agibsonccc on 10/8/14.
|
class |
Or
An or between 2 conditions.
|
| Modifier and Type | Method and Description |
|---|---|
static Condition |
Conditions.absGreaterThan()
This method will create Condition that checks if value is value X is greater than value Y in absolute values
PLEASE NOTE: This condition should be used only with pairwise methods, i.e.
|
static Condition |
Conditions.absGreaterThan(Number value)
This method will create Condition that checks if value is value X is greater than value Y in absolute values
|
static Condition |
Conditions.absGreaterThanOrEqual()
This method will create Condition that checks if value is value X is greater than or equal to value Y in absolute values
PLEASE NOTE: This condition should be used only with pairwise methods, i.e.
|
static Condition |
Conditions.absGreaterThanOrEqual(Number value)
This method will create Condition that checks if value is value X is greater than or equal to value Y in absolute values
|
static Condition |
Conditions.absLessThan()
This method will create Condition that checks if value is value X is less than value Y in absolute values
PLEASE NOTE: This condition should be used only with pairwise methods, i.e.
|
static Condition |
Conditions.absLessThan(Number value)
This method will create Condition that checks if value is value X is less than value Y in absolute values
|
static Condition |
Conditions.absLessThanOrEqual()
This method will create Condition that checks if value is value X is less than or equal to value Y in absolute values
PLEASE NOTE: This condition should be used only with pairwise methods, i.e.
|
static Condition |
Conditions.absLessThanOrEqual(Number value)
This method will create Condition that checks if value is value X is less than or equal to value Y in absolute values
|
Condition |
ConditionBuilder.build() |
static Condition |
Conditions.epsEquals()
This method will create Condition that checks if value is two values are equal wrt eps
PLEASE NOTE: This condition should be used only with pairwise methods, i.e.
|
static Condition |
Conditions.epsEquals(Number value)
This method will create Condition that checks if value is two values are equal wrt eps
|
static Condition |
Conditions.epsEquals(Number value,
Number epsilon)
This method will create Condition that checks if value is two values are equal wrt eps
|
static Condition |
Conditions.epsNotEquals()
This method will create Condition that checks if value is two values are not equal wrt eps
PLEASE NOTE: This condition should be used only with pairwise methods, i.e.
|
static Condition |
Conditions.epsNotEquals(Number value)
This method will create Condition that checks if value is two values are not equal wrt eps
|
static Condition |
Conditions.equals()
This method will create Condition that checks if value is two values are equal
PLEASE NOTE: This condition should be used only with pairwise methods, i.e.
|
static Condition |
Conditions.equals(Number value)
This method will create Condition that checks if value is two values are equal
|
static Condition |
Conditions.greaterThan()
This method will create Condition that checks if value is value X is greater than value Y
PLEASE NOTE: This condition should be used only with pairwise methods, i.e.
|
static Condition |
Conditions.greaterThan(Number value)
This method will create Condition that checks if value is value X is greater than value Y
|
static Condition |
Conditions.greaterThanOrEqual()
This method will create Condition that checks if value is value X is greater than or equal to value Y
PLEASE NOTE: This condition should be used only with pairwise methods, i.e.
|
static Condition |
Conditions.greaterThanOrEqual(Number value)
This method will create Condition that checks if value is value X is greater than or equal to value Y
|
static Condition |
Conditions.isFinite()
This method will create Condition that checks if value is finite
|
static Condition |
Conditions.isInfinite()
This method will create Condition that checks if value is infinite
|
static Condition |
Conditions.isNan()
This method will create Condition that checks if value is NaN
|
static Condition |
Conditions.lessThan()
This method will create Condition that checks if value is value X is less than value Y
PLEASE NOTE: This condition should be used only with pairwise methods, i.e.
|
static Condition |
Conditions.lessThan(Number value)
This method will create Condition that checks if value is value X is less than value Y
|
static Condition |
Conditions.lessThanOrEqual()
This method will create Condition that checks if value is value X is less than or equal to value Y
PLEASE NOTE: This condition should be used only with pairwise methods, i.e.
|
static Condition |
Conditions.lessThanOrEqual(Number value)
This method will create Condition that checks if value is value X is less than or equal to value Y
|
static Condition |
Conditions.notEquals()
This method will create Condition that checks if value is two values are not equal
PLEASE NOTE: This condition should be used only with pairwise methods, i.e.
|
static Condition |
Conditions.notEquals(Number value)
This method will create Condition that checks if value is two values are not equal
|
static Condition |
Conditions.notFinite()
This method will create Condition that checks if value is NOT finite
|
| Modifier and Type | Method and Description |
|---|---|
ConditionBuilder |
ConditionBuilder.and(Condition... conditions) |
ConditionBuilder |
ConditionBuilder.eq(Condition... conditions) |
ConditionBuilder |
ConditionBuilder.or(Condition... conditions) |
| Constructor and Description |
|---|
And(Condition... conditions) |
ConditionEquals(Condition... conditions) |
Not(Condition condition) |
Or(Condition... conditions) |
Copyright © 2020. All rights reserved.


Select Tickets
___________
STEP 1
Please select the day when you want to join us in Anime Revolution 2021!Ticket
1-Day-Ticket
2-Day-Ticket
Date
15.Oct (Thu)
16.Oct (Fri)
15.-16. Oct (Thu-Fri)
Normal
￦70,000
￦70,000
￦100,000
Students
￦30,000
￦30,000
￦50,000
Affiliate / Partners
X
X
￦0
Select Your Lunch
___________


{extends file="tpl/index.html"} {block name="htitle" prepend}Paper upload | {/block} {block name="content"}


2019-02-12 - Physical Modeling
- make an appointment with me
- fill out final presentation time/day poll
- simplest filter
- circular buffer
- moving average
- analysis/resynthesis
- mass-spring (mass == 1)
struct SimpleFilter {
float lastInput{0};
float operator()(float input) {
float returnValue = (input + lastInput) / 2;
lastInput = input;
return returnValue;
}
};
(Compare sine sweep to filtered sine sweep; Compare impulse sweep to filtered impulse sweep.)
impulse-sweep.exe | mean-filter.exe | mean-filter.exe | mean-filter.exe | mean-filter.exe | write.exe out-filtered.wav
(Compare these to output of repeated application.)


Made by Dolton Fernandes
2nd in All Goa Vedic Math Competition
4th in Maharashtra in Ideal Play Abacus
Topped Don Bosco High School Panjim in SSCE with 92.67%
Got highest score in GOA in SSCE Math exam (100%)
Got along with my band to the finals of Vem Cantar 2015 Goa


MSNBC analyst: Republicans know that Trump is a 'classic scumbag'
by Joseph WulfsohnMSNBC political analyst Elise Jordan declared on Friday that Republican lawmakers know that President Trump is a "classic scumbag."
The "Morning Joe" panel had some fun at the expense of former Attorney General Jeff Sessions, who has been touting his undying support for Trump in his campaign for his old Senate seat in Alabama.
"Elise, everybody Republican I’ve spoken with behind the scenes, they just shake their head," Scarborough said. "They’re like, 'God...' They are counting the days until Donald Trump leaves office."
"Why not impeach?" Jordan asked.
"If they could turn off all the lights in the Senate when they voted to convict, they would all vote to convict him and have Mike Pence as president in a second," Scarbrough continued.
 They know he’s corrupt. They know that his behavior is just a classic scumbag," Jordan said. "And yet they just take it every- single- day."
CLICK HERE TO GET THE FOX NEWS APP
Jordan is a long-time critic of President Trump. In 2017, the former Bush White House aide compared Trump to a “suicide bomber."


John Smith's panel show appearances
John Smith has appeared in 19 episodes between 1982-1992. Note that these appearances may be for more than one person if multiple people have the same name.
- 1992-06-11 / Question Time
- 1992-04-02 / Question Time
- 1992-01-23 / Question Time
- 1991-04-25 / Question Time
- 1991-01-31 / Question Time
- 1990-10-25 / Question Time
- 1990-06-21 / Question Time
- 1990-03-22 / Question Time
- 1989-10-05 / Question Time
- 1989-05-04 / Question Time
- 1988-06-16 / Question Time
- 1987-10-01 / Question Time
- 1987-03-19 / Question Time
- 1986-06-19 / Question Time
- 1986-01-30 / Question Time
- 1984-06-21 / Question Time
- 1983-11-24 / Question Time
- 1983-02-10 / Question Time
- 1982-04-01 / Question Time


Released with little fanfare this move to more muted songwriting is proof Swift’s music can thrive without the celebrity drama.
The lockdown may have been a terrible moment for music and musicians, but it has resulted in Taylor’s Swift’s most powerful and mature album to date.
Swift’s currency has always been emotional honesty, but now it feels less like showmanship and more like a personal reckoning. Folklore is a clear-eyed, subdued affair that reveals a little more magic with each listen.
Folklore is sad, beautiful, somewhat tragic, a little bit off the wall, but most of all it feels free.
In this record - in large part a remote collaboration between Taylor and The National’s Aaron Dessner - Taylor is contemplative, authorial, clear and simply exceptional.
folklore is an unexpected treat in the middle of a disrupted summer, one whose sepia-toned colour palette and muted production only adds to its magic.
As a complete body of work, folklore is Swift’s most compelling and challenging record since Reputation. No longer a former “country starlet gone pop,” Swift is a woman with a singular vision moving forward to blaze new paths and create art that will resonate for years to come.
The singer-songwriter's eighth album cuts away the pop scaffolding for dark, dreamy contemplation.
This is an album of Swift at her most knowing, pushing away the tabloid fodder that has often surrounded her artistry and magnifying the talent she's been honing her entire life.
Her eighth album is a radical detour into the deepest collection of songs she’s ever come up with.
As surprising as the release of the record is, possibly more surprising will be seeing folklore become the record that turns a whole generation of dismissers into actual fans.
It isn’t the weight of the subject matter alone that makes the album feel so vital—it’s the exemplary caliber of her writing. She may sing of wasted potential, but Folklore finds Swift living up to all of the praise she earned for her songwriting earlier in career.
Simply put, folklore is a speed bump. It is a small sliver of familiarity and nostalgia that broadcasts openness without resentment, mockery or one-sided representations, and finds Swift finally committing to shedding the brash, poppy sound in favor of the soft, tonal glow of reverb and contemplation.
Swift’s big 2020 plans for a long Lover tour were scrapped due to the coronavirus pandemic. But that empty window of time is what forced her to think outside the box, beyond what anyone expected of her, and to create one of her best, most perfectly-produced projects ever. In folklore, she wrote a quieter, more thought-provoking chapter in her constantly shapeshifting story.
This rich isolation album boasts collaborations with Bon Iver and The National's Aaron Dessner, and might just feature Taylor's best song ever.
This is an unconventional record – at least for the world’s biggest pop star. It’s also brilliant.
Whether as a quarantine-induced folk detour along Swift’s pop trajectory or as a hint at a new direction for her music, Folklore is an unexpected work of genuine emotion.
On Taylor Swift's surprise Lock Down album, Folklore, the omnipresent, world-conquering princess of self-mythology embraces a brooding post-pop texture that strikes a balance between lusty exuberance and indie-folky introspection.
Combined, the moodier, contemplative tone and the emphasis on songs that can't be parsed as autobiography make folklore feel not like a momentary diversion inspired by isolation but rather the first chapter of Swift's mature second act.
folklore reveals an earnestness and eloquence that Swift has never before expressed to such an extent. Like the towering trees on its cover, it’s a testament to both steadfastness and growth.
It’s easy to attack folklore: Too calm, too snoozy, the outcome of a multi-millionaire hiring indie songwriters to help her deliver “real” music. And at 63 minutes and 16 tracks, it continues the recent trends of fairly good pop albums that overstay their welcome.
In Swift’s ever-morphing musical output from acoustic country to glittering arena-ready pop, folklore’s sad-but-polished indie is a welcome break from expectation. Sure, it’s about seven tracks too long, overly-saccharine and with a penchant for over-dramatics, but it’s pretty good.
Where it ultimately stands within her catalogue will take more time to decipher, but folklore nonetheless feels like a watershed moment for Swift. It's proof positive that she's one of our better pop chameleons, and a palette cleanser after several intriguing, if sometimes questionable, sonic detours.
Taylor Swift continues her upward artistic trajectory on Folklore.
Once again, listeners must dig through a veritable mountain of songs to find the gold nuggets that are always present on her albums. But they are becoming fewer and farther between.
If you’re after sincere, sensitive twee folk with plenty of heart then Folklore is a pleasing LP. This is an oversubscribed genre though, and one that is being done in more engaging ways elsewhere.


PORTFOLIO
Take a look at a few of my works
UI/UX Design and Development
TRIVIUMS
Triviums is a game app that enhances the thinking faculty.
UI/UX Design and Development
YorubaName
Triviums is a game app that enhances the thinking faculty.
UI/UX Design and Development
TRIVIUMS
Triviums is a game app that enhances the thinking faculty.


or
Requires version 1.0.1 or higher.
This browser is not supported as it doesn't support JavaScript.
Hosted by GitHub Pages


the and that children biological from (). children’s with reasoning were for al., about anthropocentric their animals this The human non-human reading {background was book books humans property are not other Animal young Berenstain than which margin more novel perspective they urban {border-style Encyclopedia natural This but px;} #ffffff;} dog have these Bears also bears cultural one (e.g., child likely each experimenter puppet then -year-old But animal between picture world different either evidence extend had introduced may results whether Children how learning over revealed when within -year-olds human-centered less patterns primed read support two < Science adopt andro been children, influence media only our perspective, px; research those who work world. {font-family For adopted all animals. bear developmental font-size inductive influenced pattern priming reveal she them (Carey, .), First Herrmann National both double; encounter first her images into like phase photographs presented projections provide relation test vs. would (Berenstain Children’s Cogn. Dev.–./ Native She University after among anthropocentrism asked base begin books, border-color border-width can communities, depicted differences direct dog) during early included information living main might new perspectives previous real reason represented showed solid; stance, task way {font-style {font-weight (Animal Base Bears) First, Learning NSF Press Research What address affect another bold book. books. child’s construal courier; did distinctly does effect effect. em; has induction little model, pictures portraying predicted, provided pt;} recent rural served should sometimes stance standard target teaching tendency upon where written


Click here if you'd like to go back to the main page - {% if myuser %} thanks for trying out this demo {{ myuser.user.nickname }}. {% else %} you can login there! {% endif %}


The semantics of nonblocking communication is defined by suitably extending the definitions in Section Semantics of Point-to-Point Communication .
Order Nonblocking communication operations are ordered according to the execution order of the calls that initiate the communication. The non-overtaking requirement of Section Semantics of Point-to-Point Communication is extended to nonblocking communication, with this definition of order being used.
Example
Message ordering for nonblocking operations.
CALL MPI_COMM_RANK(comm, rank, ierr) IF (RANK.EQ.0) THEN CALL MPI_ISEND(a, 1, MPI_REAL, 1, 0, comm, r1, ierr) CALL MPI_ISEND(b, 1, MPI_REAL, 1, 0, comm, r2, ierr) ELSE IF (rank.EQ.1) THEN CALL MPI_IRECV(a, 1, MPI_REAL, 0, MPI_ANY_TAG, comm, r1, ierr) CALL MPI_IRECV(b, 1, MPI_REAL, 0, 0, comm, r2, ierr) END IF CALL MPI_WAIT(r1, status, ierr) CALL MPI_WAIT(r2, status, ierr)The first send of process zero will match the first receive of process one, even if both messages are sent before process one executes either receive.
Progress A call to MPI_WAIT that completes a receive will eventually terminate and return if a matching send has been started, unless the send is satisfied by another receive. In particular, if the matching send is nonblocking, then the receive should complete even if no call is executed by the sender to complete the send. Similarly, a call to MPI_WAIT that completes a send will eventually return if a matching receive has been started, unless the receive is satisfied by another send, and even if no call is executed to complete the receive.
Example
An illustration of progress semantics.
CALL MPI_COMM_RANK(comm, rank, ierr) IF (RANK.EQ.0) THEN CALL MPI_SSEND(a, 1, MPI_REAL, 1, 0, comm, ierr) CALL MPI_SEND(b, 1, MPI_REAL, 1, 1, comm, ierr) ELSE IF (rank.EQ.1) THEN CALL MPI_IRECV(a, 1, MPI_REAL, 0, 0, comm, r, ierr) CALL MPI_RECV(b, 1, MPI_REAL, 0, 1, comm, status, ierr) CALL MPI_WAIT(r, status, ierr) END IFThis code should not deadlock in a correct MPI implementation. The first synchronous send of process zero must complete after process one posts the matching (nonblocking) receive even if process one has not yet reached the completing wait call. Thus, process zero will continue and execute the second send, allowing process one to complete execution.
If an MPI_TEST that completes a receive is repeatedly called with the same arguments, and a matching send has been started, then the call will eventually return flag = true, unless the send is satisfied by another receive. If an MPI_TEST that completes a send is repeatedly called with the same arguments, and a matching receive has been started, then the call will eventually return flag = true, unless the receive is satisfied by another send.


More...
Definition at line 10 of file Space4.cs.
◆ Space4()
| droid.Runtime.Utilities.Structs.Space4.Space4 |
( |
int |
decimal_granularity = 2 | ) |
|
◆ ClipNormaliseRound()
| Vector4 droid.Runtime.Utilities.Structs.Space4.ClipNormaliseRound |
( |
Vector4 |
v | ) |
|
- Parameters
-
- Returns
Definition at line 139 of file Space4.cs.
◆ RandomQuaternion()
| Quaternion droid.Runtime.Utilities.Structs.Space4.RandomQuaternion |
( |
| ) |
|
◆ Round()
| float droid.Runtime.Utilities.Structs.Space4.Round |
( |
float |
v | ) |
|
- Parameters
-
- Returns
Definition at line 196 of file Space4.cs.
◆ Sample()
| dynamic droid.Runtime.Utilities.Structs.Space4.Sample |
( |
| ) |
|
◆ _decimal_granularity
| int droid.Runtime.Utilities.Structs.Space4._decimal_granularity |
◆ _distribution_sampler
◆ _Max_Values
| Vector4 droid.Runtime.Utilities.Structs.Space4._Max_Values |
◆ _Min_Values
| Vector4 droid.Runtime.Utilities.Structs.Space4._Min_Values |
◆ normalised
| bool droid.Runtime.Utilities.Structs.Space4.normalised |
◆ DecimalGranularity
| int droid.Runtime.Utilities.Structs.Space4.DecimalGranularity |
|
getset |
◆ DistributionSampler
◆ IsNormalised
| bool droid.Runtime.Utilities.Structs.Space4.IsNormalised |
|
getset |
◆ MinusOneOne
| Space4 droid.Runtime.Utilities.Structs.Space4.MinusOneOne |
|
staticget |
◆ Span
| Vector4 droid.Runtime.Utilities.Structs.Space4.Span |
|
get |
◆ TwentyEighty
| Space4 droid.Runtime.Utilities.Structs.Space4.TwentyEighty |
|
staticget |
◆ Wspace
| Space1 droid.Runtime.Utilities.Structs.Space4.Wspace |
|
get |
◆ Xspace
| Space1 droid.Runtime.Utilities.Structs.Space4.Xspace |
|
get |
◆ Yspace
| Space1 droid.Runtime.Utilities.Structs.Space4.Yspace |
|
get |
◆ ZeroOne
| Space4 droid.Runtime.Utilities.Structs.Space4.ZeroOne |
|
staticget |
◆ Zspace
| Space1 droid.Runtime.Utilities.Structs.Space4.Zspace |
|
get |
The documentation for this struct was generated from the following file:
- /home/heider/Projects/Neodroid/Unity/Examples/Assets/droid/Runtime/Utilities/Structs/Space4.cs


{% extends "main/base.html" %} {% block title %}Code Jams | Banned{% endblock %} {% block og_title %}Code Jams | Banned{% endblock %} {% block content %}
Thanks for your interest in this code jam! Unfortunately, due to your previous actions, you have been
permanently banned from participating in our code jams.
The reason given is: {{ infraction.reason }}
If you feel that this is a mistake, please feel free to contact one of the admins on Discord.
Thanks for your interest in this code jam! Unfortunately, due to your previous actions, you have been
temporarily banned from participating in our code jams.
The reason given is: {{ infraction.reason }}
If you feel that this is a mistake, please feel free to contact one of the admins on Discord.


{{template "layout.html"}}
Select your classes (ctrl-click for multiple)
Show
The above select requires JS. You can also append the classes to the urls. Ex: /cs100,cs221
HW Fetcher fetches handin information and other class information from the course website. If you want to add more information, please send a PR on GitHub.
https://github.com/d4l3k/hw-fetcher


A few days ago, I was in some internal training where we went through an exercise to help us determine our core values. While to some degree I already knew what my values were, I found the exercise helped me put my core values into perspective against the backdrop of the rest of my values. This exercise also helped explain some of what I've found most frustrating at work.
My core values are interrogation, trust, and openness.
This is an odd one, that I doubt you'd see if you were to Google for a list of personal values. But I've learned that it's really important to me to "dig in", to ask (and answer!) questions that are difficult to answer with my current level of understanding.
Continual growth is a common value (I hope, anyways), and it's somewhat related. You have to grow, to learn, and to become more capable to interrogate systems you don't understand. While the understanding is important (vital, in fact), that's not what's most important to me. What I find important, is the ability to be confronted with a problem I don't understand, and to pull on whatever threads I find until I construct an understanding that's useful enough to take action on. It's about saying "Huh. This doesn't match my expectation. Why?"
It's also related to "drive". It takes strategic planning, patience, dedication, and the ability to be frustrated without getting discouraged to start pulling on threads. Most importantly though, it also requires you to recognize tunnel vision so that you can pull back and ask "What am I actually trying to do here?".
I tend to do depth-first searches rather than breadth-first. The unfortunate thing about software, is that there's a huge amount of depth -- eventually, you get to the fundamental laws of mathematics, and let me tell you what, my manager loves being told a bug fix is mathematically impossible. So it's important to know when to start popping sub-problems off the stack so you can focus on things to move you closer to your goals.
At work, we recently updated a project to use Rust 1.62.1 instead of 1.60.0 (the feature we wanted was stabilized in 1.61.0, but 1.62.1 was the latest stable release at the time), and doing so broke a doctest somewhat unexpectedly -- all of a sudden, that particular test could no longer find a shared library!
Eventually, I found the issue by running rustdoc
from 1.60.0 and 1.62.1 with
strace
, and then diffing a few million lines of output, which was a messy diff, because the
strace logs contained version numbers, timestamps, and hashes, which were uninteresting diffs.
After getting my difftool to ignore these uninteresting differences, I was able to determine the cause to be rust#95604, which was exacerbated by cargo#8531 but only after significant. (but super interesting) effort.
The result? We disabled that test, which was the original recommendation of the team, but I wasn't comfortable disabling a test without first knowing why it was failing.
A colleague volunteered to work on a bug ticket in a system I'm very familiar with (I wrote the bug 🙁). I gave them some advice, and told them I had a suspicion of which subsystem the bug was in, but that the application log files would tell them for sure, as long as they changed the log level to DEBUG.
So I recommended turning up the default log level to DEBUG before attempting to reproduce. I made this recommendation over several standups, and to my dismay, this colleague had no interest in looking at the logs.
After we finally reproduced the issue together in an unrelated meeting several weeks later, and wouldn't you know it, looking at the logs pointed out the root cause in a single digit number of minutes.
Of course I knew what to look for, and I knew that the information was there. But my colleague wasn't willing to "dig in" to the logs (they're somewhat verbose, but if you turn only the subsystem you're interested in to DEBUG level, they have a pretty high signal-to-noise ratio).
I've found this to be true over the last few years -- that I tend to immediately jump to looking at the log files (or core dumps and screenshots; things that are tangible and can't be argued with), even going as far as regularly comparing the log files of one system to an adjacent, related system. It's a skill that I've built up over time; being able to debug a system by reconstructing the events from logs files. And I've put significant effort in making the software I work on understandable by paying close attention to what we log, and when we log it. But what I've found when suggesting to coworkers that they look at the logs, is that they don't want to "dig in", to start looking at what actually happened, and why that might not match their expectation of what should happen.
This is frustrating, when "digging in" is something I highly value -- especially when I know the information we need is there (because I put it there!) -- and it's not valued by my peers.
I've also learned that I value freedom. I don't respond well when I'm told how to do something, especially if it's something I'm a subject matter expert in (or even just barely competent, like washing the dishes, but that's a story I do not want to expound on).
For example, this has come up at work in how we approve and merge pull requests. Someone was upset with a recent change, and changed the project settings so that only a few people could approve and merge pull requests. This person was not a project owner, and made this change without expressing their concern, or talking to the rest of the team.
So now, I can review someone else's code, but my approval is no longer good enough?! And when it is approved, even by one of the select few, I can't even merge it?!?! As a senior engineer, and an owner of the project?!
Now don't get me wrong, it's not the freedom to write and merge whatever I damn well please that I'm after. I understand the value of code review, and believe that every submission should be reviewed.
But what happened, was that someone was disappointed, decided they didn't trust the team, and instead of building up that trust, instead of addressing the issue, they built up nonsensical controls that perpetuated the lack of trust.
It's easy to focus on freedom, as it's easier to measure. But it wasn't the change in freedom that bent me out of shape. I think it's perfectly acceptable to have a list of who can and can't approve pull requests. What I learned about myself, is that I value trust, and that I don't function well in a team that doesn't trust each other.
When you are in such a team (I am now, and I love it), this trust results in quite a few positive outcomes
This has come up when discussing certain design patterns in projects owned by other teams. There's a certain family of projects at work, where the owner doesn't trust the technical excellence of their team, which caused them to reach for some quite complex design patterns to make things "just magically work" without trusting the team to understand what the needs of each project are, and to configure them appropriately. This colleague's goals is no No-Code their way to victory. That would be a quite cool technical achievement, but my perspective is that it's born from a lack of trust (which isn't completely baseless, there's opportunities for excellence anywhere and everywhere).
Instead of responding to a lack of trust by throwing up more and more controls, I value responding by building up the trust level -- doing more training, having conversations on what I want to see in a high quality piece of software.
A culture of trust and respect results in freedom.
Strong opinions loosely held.
I'm an opinionated person, and the ability to express my opinions is important to me. I do not hesitate to say "I disagree, here's what I think, and why", and it's important to me that I work in an environment where this is possible. But I work on a team full of opinionated engineers who don't hesitate to voice their own opinions. And our opinions are all different.
Your first reaction might be "That sounds hellish, how do you get anything done?" but I really quite the dynamic. I think it's only successful because of the culture of trust and mutual respect that the team has built over the past few months.
One of the ways I think we've built this culture, is through being open to changing our opinion, and through being open to trying something that doesn't quite sit comfortably. It's sometimes pretty hard -- a lot of our opinions are on things that we've personally experience pain with, and we don't want to experience that pain again! This can result in very strongly held opinions.
There's a few ways that we've still been able to be productive without requesting transfers to another team. To a person, we're all open to changing our opinions when presented a (compelling) reason. Sometimes though, we have to say "Okay, I don't quite agree, but I'm willing to help you try it out". This has been important, because each team member has different strengths, and is a subject matter expert in some part of the system. So we frequently say "Seeing this surprised me, I initially though that might be better". Sometimes, the resolution is "Oh, yeah, that's pretty sweet". Sometimes though, the resolution is "I tried that, but here's why it didn't work".
Sometimes, I've even found us having heated disagreements over how much we agree. Communication is the single hardest thing about my job, and I'm not sure that will ever stop being true. We often have the same values, and come to different conclusions. We also commonly use different words to say the same thing, but we don't quite understand what the other person is saying, so we immediately jump to disagreeing with them (because we know that we're right). The helpful thing to do in these kinds of conversations, is to try to identify why we're disagreeing, and even what we're disagreeing about.
I value being opinionated, but this must be tempered with being open to changing my opinion. I still struggle with this, and have to be intentional when I approach conversations. I've found that even identifying disagreement can help its resolution. We often argue without even knowing what we're arguing about. It's pretty helpful to try to restate what someone else's opinions are, without making any kind of judgement on them -- "Can I try to restate your opinion to make sure I understand? You think ... because ...?"
Being opinionated only works in an environment of trust and a willingness to change your opinion.


Coursera AngularJs Assignment 1
Enter Food Items:
{{output}}
Reference Link for Above UI:
Coursera Single Page Web Applications with AngularJS Module 1 Coding Assignment


Aishwarya, Abhishek and Aaradhya arrive in Mumbai after holidaying in Rome
by TIMESOFINDIA.COMAishwarya Rai Bachchan turned a year old on November 1 and celebrated her 46th birthday in Rome with husband Abhishek and daughter Aaradhya. From slipping into a dreamy satin dress for her birthday bash to touring the Italian capital like a tourist, Aishwarya and Abhishek treated fans with several clicks from their holiday.
The Bachchan family were snapped at the airport last night, returning home after their lavish rendezvous. At the airport, the couple was twinning in black while daughter Aaradhya was dressed in a white tracksuit.
 Later, the actress had posted a series of pictures where the trio was seen exploring the city. On the work front, Aishwarya was last seen in ‘Fanney Khan’ along with Anil Kapoor and Rajkummar Rao. The actress will reportedly feature in Mani Ratnam’s next ‘Ponniyin Selvan’.


hidden
LECRAYAH
Search around a 1000 Items are waiting to be sold
Search around a 1000 Items are waiting to be sold
Lorem ipsum dolor sit, amet consectetur adipisicing elit. Accusamus delectus ipsum molestiae aspernatur eos quaerat omnis consequatur doloremque illum fuga.
Stainless Pan a set of five pans
new
From:Nairobi, Kenya
Ksh.24000
Stainless Pan a set of five pans
new
From:Nairobi, Kenya
Ksh.24000
Stainless Pan a set of five pans
new
From:Nairobi, Kenya
Ksh.24000
Stainless Pan a set of five pans
new
From:Nairobi, Kenya
Ksh.24000
Stainless Pan a set of five pans
new
From:Nairobi, Kenya
Ksh.24000
Stainless Pan a set of five pans
new
From:Nairobi, Kenya
Ksh.24000
Stainless Pan a set of five pans
new
From:Nairobi, Kenya
Ksh.24000
Stainless Pan a set of five pans
new
From:Nairobi, Kenya
Ksh.24000
Stainless Pan a set of five pans
new
From:Nairobi, Kenya
Ksh.24000
Stainless Pan a set of five pans
new
From:Nairobi, Kenya
Ksh.24000
Stainless Pan a set of five pans
new
From:Nairobi, Kenya
Ksh.24000
Stainless Pan a set of five pans
new
From:Nairobi, Kenya
Ksh.24000
Stainless Pan a set of five pans
new
From:Nairobi, Kenya
Ksh.24000
Stainless Pan a set of five pans
new
From:Nairobi, Kenya
Ksh.24000
Stainless Pan a set of five pans
new
From:Nairobi, Kenya
Ksh.24000
Stainless Pan a set of five pans
new
From:Nairobi, Kenya
Ksh.24000
Stainless Pan a set of five pans
new
From:Nairobi, Kenya
Ksh.24000
Stainless Pan a set of five pans
new
From:Nairobi, Kenya
Ksh.24000


Performs simple and canonical CA (covariates on rows/columns) on a two-way frequency table (with missings) by means of SVD. Different scaling methods (standard, centroid, Benzecri, Goodman) as well as various plots including confidence ellipsoids are provided.
| Version: | 1.1-3 |
| Depends: | R (≥ 3.0.2) |
| Imports: | graphics, stats, car, colorspace, fda, splines, grDevices |
| Published: | 2017-05-01 |
| Author: | Patrick Mair [aut, cre], Jan De Leeuw [aut] |
| Maintainer: | Patrick Mair <mair at fas.harvard.edu> |
| License: | GPL-2 |
| Copyright: | see file COPYRIGHTS |
| URL: | http://r-forge.r-project.org/projects/psychor/ |
| NeedsCompilation: | yes |
| Citation: | anacor citation info |
| In views: | Psychometrics |
| CRAN checks: | anacor results |
| Reference manual: | anacor.pdf |
| Package source: | anacor_1.1-3.tar.gz |
| Windows binaries: | r-devel: anacor_1.1-3.zip, r-release: anacor_1.1-3.zip, r-oldrel: anacor_1.1-3.zip |
| OS X binaries: | r-release: anacor_1.1-3.tgz, r-oldrel: anacor_1.1-3.tgz |
| Old sources: | anacor archive |
Please use the canonical form https://CRAN.R-project.org/package=anacor to link to this page.


Last updated: {{last_updated}}
Update (01/04/12): Fixed the bug that was truncating last character in comments
Update (12/23/11): Reached AppEngine Quotas (DataStore DELETE) so had to enable billing for the app and modify API calls to handle errors better. The API and app are fully functional now.
Update (10/23/11): The API now supports nested comments as a new API call (/nestedcomments) (thanks to Suan Aik Yeo). The old comments API (/comments) has been deprecated.
Update (10/22/11): Thanks to my friend Eric I now have a dedicated server to handle API traffic. The API has been down for a few hours on Friday, October 21st because of GAE urlfetch (DownloadError: ApplicationError: 2) errors. Apparently, GAE started to deny requests to HN so the data had to be retrieved from another server. The API still runs on GAE but the data is being fetched from another server and then provided to GAE instances for processing.
There's five minute caching for main content entry points (/news, /best, /ask, /newest); there's no caching for paginated content (requests that require pageID).
Full source code available on GitHub. For any questions please drop me a note (). Cheers, Gleb Popov
API Index:
- Homepage
- Homepage Page 2
- Comments (deprecated)
- Nested Comments
- Latest
- Newest
- Best
- Ask
- Submitted


The main purpose of Arttic Fox is helping small businesses with their digital needs. We approach every problem as it is an opportunity. We look at the problem and try to solve with data-driven desitions.  Their success takes us farther as well.
We never looked at any project as big or small. Every client brings us new opportunities for proving ourselves as a reliable problem solvers.
65 scadding ave. M5A4L1
Toronto / Ontario / Canada
white@artticfox.com


este.ui.FormsPersister
Maintain fields state. Click to field, write something, reload.
input
textarea
select
Foo
Bla
multiselect
Foo
Bla
Male
Female
I have a bike
I have a car
reload page
reset form
restore state
innerHTML form


The most extreme rains of today are set to become more commonplace
For every 1 ºC of global warming, the frequency of the heaviest rainfalls will nearly double.
Very heavy rainfalls that are rare in our current climate are likely to become more common as precipitation patterns shift in a warming world.
Scientists have projected that climate change will increase average global precipitation, because in a warmer atmosphere the air has higher concentrations of water vapour. For the same reason, the heaviest downpours of the future might be even more drenching than the most intense rains of today.
Gunnar Myhre at the Center for International Climate Research in Oslo and his colleagues investigated whether global warming might also change the frequency of extreme precipitation events. Using historical weather records and climate-model simulations, the team found that the heaviest precipitation events of today will probably occur almost twice as often with each further degree of global warming.
The total amount of precipitation from extreme weather events is therefore also likely to roughly double per degree, with potentially severe impacts on societies.


Home
Services
News
FAQ's
Useful Links
About
Login Here
Login Here
Username
Password
Forget Password
Sign Up


WARNING: This list is based on a opinion. 1. Albert Einstein 2. Marie Curie 3. Benjamin Franklin 4. Thomas Edison 5. Sphurthy Gangapuram 6. Kill Bill Pandey (Bramhanandam)


type: object
| Field | Required | Type | Description |
|---|---|---|---|
location |
required | LatitudeLongitudeLiteral | See LatitudeLongitudeLiteral for more information. |
placeId |
required | string | A unique identifier for a place. All place IDs returned by the Roads API correspond to road segments. |
originalIndex |
optional | number |
An integer that indicates the corresponding value in the original
request. Each value in the request should map to a snapped value in the
response. However, if you've set interpolate=true, then it's possible
that the response will contain more coordinates than the request.
Interpolated values will not have an originalIndex . These
values are indexed from 0 , so a point with an originalIndex
of 4 will be the snapped value of the 5th
latitude/longitude passed to the path parameter.
|


[§46-19.4 Priority permitting process for renewable energy projects.] All agencies shall provide priority handling and processing for all county permits required for renewable energy projects.
For purposes of this section, "agencies" means any executive department, independent commission, board, bureau, office, or other establishment of a county, or any quasi-public institution that is supported in whole or in part by county funds. [L 2007, c 205, §2]
Cross References
Other related sections, see §§196-1.5, 201-12.5, 201N-14, and 226-18(c)(10).


LMV Extractor Node.js Sample
Edit dependencies
Click and drag new dependencies from the orange square in each element. Click on a connection to delete it.

Existing projects
Once a project get translated, you can either view or inspect data.