You can find on this page a collection of all the tutorials and lessons I have created myself over time. All the materials are available for download as pdf files.
Important: uploading all the tutorials and lessons I have made so far will take a long time. If the chapter or tutorial you are interested in has not been uploaded yet, please come back later or contact me.
Tutorials
Tutorials are step by step guides dealing with programming languages (e.g. Python, LabVIEW) or softwares (e.g. ImageJ). Unlike a lesson which has a set syllabus, the tutorials will likely evolve over time and more materials will be added continuously.
Python
The tutorials on Python have not been uploaded yet. Please bear with me while I add all the documents.
LabVIEW
The tutorials on LabVIEW have not been uploaded yet. Please bear with me while I add all the documents.
Lessons
Lessons are lengthy explanations and demonstrations on a selected topic. Unlike the tutorials, the lessons will explore the different subjects in depth to explain all the details.
Statistics
Introduction to statistics and data analysis, from simple average and variance to fit algorithms and hypothesis tests.
This lesson was made for a workshop on Python and Data Analysis that took place in 2019 at the Department of Chemistry of the King’s College London (London, UK).


Understanding neuroplasticity principles can benefit people in a way that they are more aware of the effects of this concept which in-tern means that people are more likely to be motivated to keep at ‘practise’ or learning new things, even through difficulties. Someone who understands, that this concept of learning has been studied and proven to work, are more likely to be motivated and convinced that “if I keep at it even though its hard, I can master anything I am trying to achieve” - helping them achieve what that desire to achieve.
How I see myself engaging with neuroplasticity principals for my own benefit would be when I feel like I have spare or free time, I see myself doing activities that may interest me that I don’t normally do. I would like to utilise this free time to continue learning new skills to encourage neuroplasticity and to also motivate me to learn new skills or even skills I have shied away from due to lack in confidence or inability.
Neuroplasticity can be increased by doing creative tasks like reading fictional books, learning an instrument, intermittent fasting, travelling to new places, non-dominant hand exercises, expanding vocabulary, creating artwork and dancing to name a few. These from my research are known to enhance or boost neuroplasticity.
The below link was where I found relatable and useful information on this topic. https://positivepsychology.com/neuroplasticity/
Growth Mindset is a positive way of thinking and self belief of a standard - ‘Growth’. People with a growth mindset genuinely believe they can get smarter, more intelligent and more talented through time and effort. However in comparison, someone with a fixed mindset believe that ‘you either have it or you don’t’. These people place themselves at a benchmark and blame the rest on chance/luck. Growth mindset is relevant because it will greatly impact how well we can keep ourselves motivated throughout this journey of learning coding. If we are prepared to accept that through time and effort we are likely to succeed at becoming web developers, we will grow into such belief. With the fixed mindset, chances are that person probably didn’t even sign up if they didn’t think they were capable. Fixed mindset people are likely to be left disadvantaged to new opportunities due to their fixed ways.
Yes, that both Neuroplasticity and growth mindset are highly relatable to what I am doing right now at EDA and can be applied very directly to the course and other forms of my life. As well as this, both the topics go hand in hand. If you’re likely to have a growth mindset, you’re going to be more like to try new activities which can grow Neuroplasticity. If you’re practicing neuroplasticity, chances are you have a growth mindset to a certain degree opening yourself to learning new skills/talent.
I will Integrate a growth mindset into my learning journey by using positive regard to encourage myself when I feel like I am struggling with something and not giving up. I think its important to continually remind myself of having the growth mindset and that I am capable through time and effort. Difficulties are merely a challenge to grow stronger faster and develop deeper meaning and understanding of the difficulty.
The below link was where I found relatable and useful information on this topic. https://positivepsychology.com/growth-mindset-vs-fixed-mindset/
Nimesh Govind
Dev Academy Student | Auckland, New Zealand
Phone<PHONE_NUMBER>
Email nimeshgovind74@gmail.com


Top Level Link
Second Level Link
Third Level Link
Third Level Link
Third Level Link
Fourth Level Link
Fourth Level Link
Fourth Level Link
Fifth Level Link
Fifth Level Link
Fifth Level Link
Second Level Link
Second Level Link
Top Level Link
Top Level Link
Top Level Link
Resize your browser to under 480 pixels


Home
Diary
Expense Tracker
Add Budget
Add Expense
View Expense
To-do list
Existing Tasks
Add tasks
Sign Out
Forthcoming Events
Delete Event
Pending Events
Delete Event


Phaser.Plugin.GamygdalaExpression Class
This Phaser plugin class renders the emotions in a crude way to visualize what happens to an agent It is provided for convenience, depends on Phaser functionality, and it is not suggested that this is the only (or even preferred) way emotions should be used in a game One is free to use emotions in any way (e.g. changing gameplay, storyline, enemy behaviour, using rendered faces on the actual sprites, etc..) See gamygdala_demo.html for a clear example of how to use this class.
Constructor
Phaser.Plugin.GamygdalaExpression
-
game
-
sprite
-
agent
-
[showOnlyMaxIntensity]
Parameters:
-
game
Phaser.GameYour Phaser game
-
sprite
Phaser.SpriteThe sprite to which this expression belongs
-
agent
TUDelft.Gamygdala.AgentThe emotional agent who's emotional state will be expressed.
-
[showOnlyMaxIntensity]
Boolean optionalSetting showOnlyMaxIntensity to true shows only the expression with the highest intensity. False or omitted results in showing all.
Item Index
Methods
Phaser.Plugin.GamygdalaExpression.update
()
This is run automatically when the Phaser plugins update is performed during the core game loop It renders the emotional expression for the sprite to whom the expression is coupled


OK, listen up, I've figured out the key eternal
happiness. All you need to do is eat lots of scones.
OK, listen up, I've figured out the key eternal
happiness. All you need to do is eat lots of scones.
OK, listen up, I've figured out the key eternal
happiness. All you need to do is eat lots of scones.
OK, listen up, I've figured out the key eternal
happiness. All you need to do is eat lots of scones.
OK, listen up, I've figured out the key eternal
happiness. All you need to do is eat lots of scones.


{% set searchTerm = data.searchTerm %} {% set searchPrompt = data.searchPrompt %} {% set currentSprint = 'L1' %} {% extends "./layout.html" %} {% block head %} {% include "./includes/head.html" %} {% endblock %} {% block proposition_header %}
To use our webchat you must:
By using this webchat service you agree to our terms and conditions
You can read our privacy policy


This Application does not collect any kind of data from the user neither from its device.
This Application it is not related in any manner with third-party services it may use.
Although ngMeetup may include links providing direct access to other internet resources or services, ngMeetup creators is not responsible for the accuracy or content of information contained by them
Links from ngMeetup creators to third-party sites do not constitute an endorsement by ngMeetup creators of the parties or their products and services.
The ngMeetup creators reserves the right to make changes to this privacy policy at any time by giving notice to its Users on this section. It is strongly recommended to check this page often, referring to the date of the last modification listed at the bottom. If a User objects to any of the changes to the Policy, the User must cease using this Application.
Last modification: 15th Oct. 2015


1 : /*
2 : * jmemnobs.c
3 : *
4 : * Copyright (C) 1992-1996, Thomas G. Lane.
5 : * This file is part of the Independent JPEG Group's software.
6 : * For conditions of distribution and use, see the accompanying README file.
7 : *
8 : * This file provides a really simple implementation of the system-
9 : * dependent portion of the JPEG memory manager. This implementation
10 : * assumes that no backing-store files are needed: all required space
11 : * can be obtained from malloc().
12 : * This is very portable in the sense that it'll compile on almost anything,
13 : * but you'd better have lots of main memory (or virtual memory) if you want
14 : * to process big images.
15 : * Note that the max_memory_to_use option is ignored by this implementation.
16 : */
17 :
18 : #define JPEG_INTERNALS
19 : #include "jinclude.h"
20 : #include "jpeglib.h"
21 : #include "jmemsys.h" /* import the system-dependent declarations */
22 :
23 : #ifndef HAVE_STDLIB_H /* <stdlib.h> should declare malloc(),free() */
24 : extern void * malloc JPP((size_t size));
25 : extern void free JPP((void *ptr));
26 : #endif
27 :
28 :
29 : /*
30 : * Memory allocation and freeing are controlled by the regular library
31 : * routines malloc() and free().
32 : */
33 :
34 : GLOBAL(void *)
35 36438: jpeg_get_small (j_common_ptr cinfo, size_t sizeofobject)
36 : {
37 36438: return (void *) malloc(sizeofobject);
38 : }
39 :
40 : GLOBAL(void)
41 36227: jpeg_free_small (j_common_ptr cinfo, void * object, size_t sizeofobject)
42 : {
43 36227: free(object);
44 36227: }
45 :
46 :
47 : /*
48 : * "Large" objects are treated the same as "small" ones.
49 : * NB: although we include FAR keywords in the routine declarations,
50 : * this file won't actually work in 80x86 small/medium model; at least,
51 : * you probably won't be able to process useful-size images in only 64KB.
52 : */
53 :
54 : GLOBAL(void FAR *)
55 25122: jpeg_get_large (j_common_ptr cinfo, size_t sizeofobject)
56 : {
57 25122: return (void FAR *) malloc(sizeofobject);
58 : }
59 :
60 : GLOBAL(void)
61 25101: jpeg_free_large (j_common_ptr cinfo, void FAR * object, size_t sizeofobject)
62 : {
63 25101: free(object);
64 25101: }
65 :
66 :
67 : /*
68 : * This routine computes the total memory space available for allocation.
69 : * Here we always say, "we got all you want bud!"
70 : */
71 :
72 : GLOBAL(long)
73 2434: jpeg_mem_available (j_common_ptr cinfo, long min_bytes_needed,
74 : long max_bytes_needed, long already_allocated)
75 : {
76 2434: return max_bytes_needed;
77 : }
78 :
79 :
80 : /*
81 : * Backing store (temporary file) management.
82 : * Since jpeg_mem_available always promised the moon,
83 : * this should never be called and we can just error out.
84 : */
85 :
86 : GLOBAL(void)
87 0: jpeg_open_backing_store (j_common_ptr cinfo, backing_store_ptr info,
88 : long total_bytes_needed)
89 : {
90 0: ERREXIT(cinfo, JERR_NO_BACKING_STORE);
91 0: }
92 :
93 :
94 : /*
95 : * These routines take care of any system-dependent initialization and
96 : * cleanup required. Here, there isn't any.
97 : */
98 :
99 : GLOBAL(long)
100 5570: jpeg_mem_init (j_common_ptr cinfo)
101 : {
102 5570: return 0; /* just set max_memory_to_use to 0 */
103 : }
104 :
105 : GLOBAL(void)
106 5533: jpeg_mem_term (j_common_ptr cinfo)
107 : {
108 : /* no work */
109 5533: }
Generated: 2016-04-07 17:52 by zcov


Earn Extra Income
With These Services
We love networking and we will continue to share various businesses and their product benefits through word of mouth which will also help you generate additional income by connecting you various businesses that meet the needs of your customers.
Lorem Ipsum is simply dummy text of
Lifepharm
Lorem Ipsum is simply dummy text of the printing and typesetting industry.
Lorem Ipsum is simply dummy text of
Lifepharm
Lorem Ipsum is simply dummy text of the printing and typesetting industry.Lorem
Lorem Ipsum is simply dummy text of
Lifepharm
Lorem Ipsum is simply dummy text of the printing and typesetting industry.Lorem


Man Utd Star On Being Racially Abused, Thrown With Object
by Kurt BuckerfieldAfter being an alleged target of racial abuse from Manchester City supporters at the Etihad, where he was also hit with an object, Manchester United star Fred has discussed the shocking events from this weekend.
Click through the mini-gallery above to see some images of the incident.
Video and television evidence appeared to show a fan making a monkey gesture at the Brazilian midfielder during United's 2-1 away win at rivals City on Saturday night.
The man has reportedly since been arrested by Greater Manchester Police on suspicion of racially aggravated public order after City released a statement just as the derby ended to say they were working with authorities to find the suspected guilty parties.
Speaking after the game, a discouraged Fred, who was also hit with one of the many objects thrown at him in the second half, said he did not want to give the troublemakers any more attention.
Earn Airtime & Data With Soccer Laduma's Social Media App - Download Now
"We are still in a backward society," he told ESPN Brazil.
"On the field, I didn't see anything. I saw it only in the locker room afterwards.
"The guys showed me. He even threw a lighter and it hit me. I try not to care about that. I try to look ahead.
"Unfortunately, this is happening in some stadiums. It happened here, it happened in Ukraine with some friends. It's sad, but we have to keep our heads up and forget about that.
"We can't give them any attention because that's all they want. I spoke to the referee after the match, they will do something about it and that's all.
"We are all the same regardless of skin colour, hair and gender. We came from the same place and we all go to the same place when it's all said and done.
"Thank God, I have a lot of friends here in the locker room who hugged me, like (Jesse) Lingard.
"I don't want to think about it. I just want to move on."
Man Utd Players Suffer Alleged Racist Abuse, Man City Respond
United are now fifth in the Premier League, five points behind fourth-placed Chelsea.


| Modifier and Type | Method and Description |
|---|---|
static Piece[][] |
Utility.clone(Piece[][] input)
Perform a deep clone of a 2D array.
|
Piece |
BoardInterface.gameWon()
Checks to see if either player has won.
|
Piece |
Board.gameWon()
Checks whether red, then blue, has won, using PlayerWon.
|
Piece[][] |
BoardInterface.getBoardView()
This method will return a two dimentional array of Pieces which represents the current state of the
board.
|
Piece[][] |
Board.getBoardView()
Returns a deep copy of boardArray.
|
Piece |
HumanPlayer.getColour() |
Piece |
ComputerPlayer_xvhn44.getColour() |
Piece |
Hex.getPieceColour() |
Piece |
GameManager.getWon()
Calls board.gameWon()
|
static Piece |
Piece.valueOf(java.lang.String name)
Returns the enum constant of this type with the specified name.
|
static Piece[] |
Piece.values()
Returns an array containing the constants of this enum type, in
the order they are declared.
|
| Modifier and Type | Method and Description |
|---|---|
static Piece[][] |
Utility.clone(Piece[][] input)
Perform a deep clone of a 2D array.
|
MoveInterface |
GUIFrame.getMove(Piece[][] boardView,
Piece currentTurn) |
MoveInterface |
GUIFrame.getMove(Piece[][] boardView,
Piece currentTurn) |
MoveInterface |
HumanPlayer.makeMove(Piece[][] boardView)
Asks the player to make a move, and returns it once made
|
MoveInterface |
PlayerInterface.makeMove(Piece[][] boardView)
Ask the player to make a move.
|
MoveInterface |
ComputerPlayer_xvhn44.makeMove(Piece[][] boardView)
Runs the correct method based on AI Type - defaulting to AIType.COMBO.
|
boolean |
BoardInterface.placePiece(Piece colour,
MoveInterface move)
Places a piece on the board at the specified location.
|
boolean |
Board.placePiece(Piece colour,
MoveInterface move)
Attempts to place a piece on the board.
|
static boolean |
Utility.playerWon(Piece[][] boardView,
Piece player)
Check to see if a player has won based on a board array
|
static boolean |
Utility.playerWon(Piece[][] boardView,
Piece player)
Check to see if a player has won based on a board array
|
void |
Graph.populateGraph(Piece[][] boardView,
Piece colour)
Create nodes and edges representing the boardView passed.
|
void |
Graph.populateGraph(Piece[][] boardView,
Piece colour)
Create nodes and edges representing the boardView passed.
|
boolean |
HumanPlayer.setColour(Piece colour)
Update the colour of the player.
|
boolean |
PlayerInterface.setColour(Piece colour)
Set the colour that this player will be
|
boolean |
ComputerPlayer_xvhn44.setColour(Piece colour)
Set the colour of the player to a new colour.
|
void |
Hex.setPieceColour(Piece pieceColour)
Updates the colour of the hex
|
boolean |
GameManagerInterface.specifyPlayer(PlayerInterface player,
Piece colour)
Define who will be playing each colour.
|
boolean |
GameManager.specifyPlayer(PlayerInterface player,
Piece colour)
Define who will be playing each colour.
|
void |
GUIPanel.updateBoard(Piece[][] boardView)
Update the board, giving it a new board view to represent
|
void |
GUIFrame.updateBoard(Piece[][] boardView) |
void |
GUIBoard.updateBoard(Piece[][] boardView,
java.awt.Dimension size)
Iterates through the board array and updates the colours of the hexes.
|
void |
GUIFrame.updateWinner(Piece winner)
Notify the user of the winner on the display
|
| Constructor and Description |
|---|
DjikstraRunnable(Piece[][] boardView,
Piece colour,
java.util.ArrayList<Coordinate> freeSpaces,
java.util.HashMap<Coordinate,java.util.ArrayList<Coordinate>> freeSpacesMap)
Initialise the variables passed as parameters.
|
DjikstraRunnable(Piece[][] boardView,
Piece colour,
java.util.ArrayList<Coordinate> freeSpaces,
java.util.HashMap<Coordinate,java.util.ArrayList<Coordinate>> freeSpacesMap)
Initialise the variables passed as parameters.
|
GUIFrame(Piece[][] boardView,
java.awt.Dimension size) |
Hex(java.awt.Point northWest,
int radius,
Piece pieceColour,
Coordinate coords)
Creates a hex object, intialising the hexPoly field
|
MCTSRunnable(Piece[][] boardView,
Piece colour,
java.util.HashMap<Coordinate,java.util.ArrayList<Coordinate>> freeSpacesMap,
java.util.List<Coordinate> allFreeSpaces)
Create a new MCTSRunnable, setting the fields to the values provided by the parameters.
|
MCTSRunnable(Piece[][] boardView,
Piece colour,
java.util.HashMap<Coordinate,java.util.ArrayList<Coordinate>> freeSpacesMap,
java.util.List<Coordinate> allFreeSpaces)
Create a new MCTSRunnable, setting the fields to the values provided by the parameters.
|


Warning
This URL is not able to post to chatter
Chatter Login
Title
URL
Comment
Share to Group
[MyFeed]
Share to Chatter (Shift+Enter)


Addresses
The Organization Ontology represents addresses (postal and email) as “things” that denote organizations.
Email Addresses
IAO_0000429
is the term id for the class email address. It is an information artifact
that denotes an
organization and has a text string representation.
If y is the URI of an organization we can say y has email address<EMAIL_ADDRESS>by asserting:
y denoted_by x
x a email_address
x has_email_representation<EMAIL_ADDRESS>Because the email address is a thing, we can assign qualities to it. Email addresses may have purposes (dispositions) to help users route email effectively. We might say:
x has_disposition z
z a information_address_disposition
to indicate that x is an email address that can be used by people to ask questions and get help.
Postal Addresses
Postal addresses are represented in a manner analogous to email addresses – postal
addresses are information artifacts that denote an organization. Like email
addresses they may have qualities (dispositions) that help people use the postal
address effectively. Postal addresses are things. The term ID is IAO_0000422
.
Postal addresses are text strings in which the “parts” of a postal address are delimited by semicolons. Applications can parse these strings into parts needed by the application. Parts and parsing vary by jurisdiction but should conform to Universal Postal Union [https://www.upu.int] standards in implementations.
To say org y has a billing postal address, we can assert:
y denoted_by x
x a postal_address
x has_disposition z
z a billing_address_disposition
x has_postal_address_representation "line 1; line 2; city; region; country; postal-code"
Terms used to represent Addresses
Table 11 Terms used to represent addresses lists term ids used in the representation of addresses
Term |
Notes |
|---|---|
An organization is denoted by an address |
|
An entity with properties and a value |
|
A datatype property to contain an email address string |
|
Object property relating an entity to a disposition |
|
A quality of an adress to obtain information |
|
An entity with properties and a value for postal delivery |
|
An address used to send bills to an entity |
|
An datatype property to contain a postal address string |


{% extends "gruppeapp/base.html" %}
{% load static %}
{% block title %}About{% endblock %}
{% block body %}
About
"Group Generator" was created by Rasmus Hag Løvstad in the summer of 2017. It is built on Django with Bootstrap and JQuery.
This site is open-source, licensed under the MIT license. You can find the source code for the site here. We are welcoming contributors.
If you have any problems with the site, or you want to contact me, you can send me an e-mail at rasmus.hag.lovstad@gmail.com.


When I first moved to this city for college I wanted to try some marijuana because I had a good experience once before about a year previous. Me and my friends at that time drove to a wood before we started to smoke.
In that experience I smoked approx 2g joint of pure weed in about 5 minutes, not mixed with anything. And this being my first time was probally not the best idea. Basically Nothing happened for about ten minutes and then my vision went completely black, it kind of frazzled out.
And my balance went too so I sat down and spent the next what felt like an hour but was probally only 10 minutes sitting down listning to my friends chat. It felt like i was deep inside my own mind.  And I was thinking about deep stuff such as relationships and remember even thinking this is not good for a second or two.
While I was thinking I felt a strange thud or vibration in the back of my mind, like a layer below my thinking process, so a while later I decided to open my eyes and saw my friends looking down at me, and i muttered 'did i fall over?' yes i did. after my friends helped me up we went back to the car and the driver was going about 80mph down some old country roads and it felt like a person would come from behind a corner and we would crash, but it was more apprehensive than scary. While we were driving it felt like i was playing a rally car game and it was me driving instead of the driver.
eventually we arrived at the castle and i remember running across high walls that i could have fallen off and proballly died. When we got back to my friends house I smoked some more from his pipe and these are the feelings I had that evening:
- Out of body experience, I was behind myself and above myself looking down at my body
- Tunnel vision, when i started at the tv everything around it was blurry
- Roller walking, when I walked into the kitchen if felt like it only took a second to get there,like rollerskating
-Deep thoughts, keeping to myself and relaxed
-Music, listended to eminem and it sounded very cool
-Food, food tasted amazing, however one dry biscuit felt like sand in my mouth
-red eyes, very very red and when i asked a friend how long it took to go away because i had to go home he said 'about two weeks' lol
-dry mouth, when i got dry mouth i thought it was only an effect so didnt drink anything, then found my mouth actually was dry so got a drink
-teeth, my teeth felt huge and kept feeling them with my tounge and grinding them
-arms didnt look like they were mine.
-jaw felt missing and only my teeth and tounge were left
-weirdest feeling was my sense of being/perception that is normally in my eyes where I feel my soul is moved from my eyes to my mouth, was weird
-time distortion too.
Overall it was a good experience, shouldnt have taken so much at once but on this occasion I think it woked out.
I will post my near death experience with a legal weed next.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


The BitArray
structure provides a implementation of
monomorphic arrays of booleans implemented one bit per
element. The BitArray
structure extends the
MONO_ARRAY
signature
with bit-level operations.
Synopsis
signature BIT_ARRAY
structure BitArray :> BIT_ARRAY
Interface
include MONO_ARRAY
val fromString : string -> array option
val bits : (int * int list) -> array
val getBits : array -> int list
val toString : array -> string
val isZero : array -> bool
val extend0 : (array * int) -> array
val extend1 : (array * int) -> array
val eqBits : (array * array) -> bool
val equal : (array * array) -> bool
val andb : (array * array * int) -> array
val orb : (array * array * int) -> array
val xorb : (array * array * int) -> array
val notb : array -> array
val << : (array * word) -> array
val >> : (array * word) -> array
val setBit : (array * int) -> unit
val clrBit : (array * int) -> unit
val union : array -> array -> unit
val intersection : array -> array -> unit
val complement : array -> unit
val lshift : (array * int) -> array
val rshift : (array * int) -> array
Description
include MONO_ARRAY
-
The
BIT_ARRAY
signature extends theMONO_ARRAY
signature from the Standard ML Basis Library. Note that while theMONO_ARRAY
signature includes a corresponding monomorphicvector
type, there is currently no implementation of a correspondingBitVector
structure. val fromString : string -> array option
-
fromString s
returnsSOME ba
when the strings
is a sequence of hexadecimal digits. The length ofba
will be4*(length s)
. ReturnsNONE
of a non-hexadecimal character is encountered. val bits : (int * int list) -> array
-
bits (n, ixs)
returns a new arrayba
of lengthn
, whereba[ix]
istrue
for eachix
in the list of indicesixs
. This function raises theSize
exception ifn < 0
and theSubscript
exception if any index is out of bounds. val getBits : array -> int list
-
getBits ba
returns a list of indicesix
for whichba[ix]
is true in increasing order. val toString : array -> string
-
toString ba
returns a string representation of the array as a sequence of hexadecimal digits in little-endian order (i.e., ba[0] is represented as the high-order bit in the first digit). val isZero : array -> bool
-
isZero ba
returns true if, and only if, no elements aretrue
inba
. val extend0 : (array * int) -> array
-
extend0 (ba, n)
returns a new arrayba'
that ismax(n, length ba)
elements long, where thelength ba
elements ofba'
are copied fromba
and the remaining elements arefalse
. This function raises theSize
exception ifn < 0
. val extend1 : (array * int) -> array
-
extend1 (ba, n)
returns a new arrayba'
that ismax(n, length ba)
elements long, where thelength ba
elements ofba'
are copied fromba
and the remaining elements aretrue
. This function raises theSize
exception ifn < 0
. val eqBits : (array * array) -> bool
-
eqBits (ba1, ba2)
returns true if the two arrays have the sametrue
entries. In other words, the following identity holdseqBits(ba1, ba2) = (getBits ba1 = getBits ba2)
val equal : (array * array) -> bool
-
equal (ba1, ba2)
returns true if the two arrays are the same length and have the same elements. val andb : (array * array * int) -> array
-
andb (ba1, ba2, n)
returns a new arrayba
of lengthn
, where the elementba[ix]
is the logical AND ofba1[ix]
andba2[ix]
, where the inputs are extended withfalse
as necessary. This function raises theSize
exception ifn < 0
. val orb : (array * array * int) -> array
-
orb (ba1, ba2, n)
returns a new arrayba
of lengthn
, where the elementba[ix]
is the logical OR ofba1[ix]
andba2[ix]
, where the inputs are extended withfalse
as necessary. This function raises theSize
exception ifn < 0
. val xorb : (array * array * int) -> array
-
xorb (ba1, ba2, n)
returns a new arrayba
of lengthn
, where the elementba[ix]
is the logical XOR ofba1[ix]
andba2[ix]
, where the inputs are extended withfalse
as necessary. This function raises theSize
exception ifn < 0
. val notb : array -> array
-
notb ba
returns a new array of the same length asba
with the elements negated.
val << : (array * word) -> array
-
<< (ba, n)`returns a new array by appending `n
false
elements on the end ofba
. The new array will have length equal ton + length ba
.
val >> : (array * word) -> array
-
>> (ba, n)`returns a new array by trimming `n
elements from the "right" ofba
. The new array will havemax(0, length ba - n)
elements. val setBit : (array * int) -> unit
-
setBit (ba, ix)
sets the element ofba
at indexix
totrue
. This function raises theSubscript
exception ifix
is out of bounds. val clrBit : (array * int) -> unit
-
setBit (ba, ix)
sets the element ofba
at indexix
tofalse
. This function raises theSubscript
exception ifix
is out of bounds. val union : array -> array -> unit
-
union ba1 ba2
updatesba1
by setting each elementba1[ix]
to the logical OR ofba1[ix]
andba2[ix]
, whereba2[ix]
is extended withfalse
elements as necessary to match the length ofba1
. val intersection : array -> array -> unit
-
intersection ba1 ba2
updatesba1
by setting each elementba1[ix]
to the logical AND ofba1[ix]
andba2[ix]
, whereba2[ix]
is extended withfalse
elements as necessary to match the length ofba1
. val complement : array -> unit
-
complement ba
logically negates all of the elements ofba
.


The data collected in the return provides information about your ECE service that is not allocated elsewhere. The Ministry of Education will provide advance notice of the dates for ECE Return week.
Please enter start date for the return week specified by the Ministry of Education
Ece Return week date is not set. Add ece return week from listview


{% extends "base.html" %} {% block title%}{% endblock %} {% block header %} {% endblock %} {% block content %}
View earlier messages
{{line.line}}
{{chat_meta.get('topic','')}}
{% for group in groups %} {% for char in characters[group] %} {{char}} {% endfor %} {% endfor %}
Prefix:
Suffix:
Case: {% for case in case_options.items()|sort %} {{case[1]}} {% endfor %}
Replacements:
Add Clear
Apply Cancel
Did you enjoy that chat? If so, remember to save the log - the chat will be deleted from this URL in 7 days.


EBD - Easton Bible DIctionary
Lucre
LUCRE
"LUCRE "from the Lat. lucrum, “gain.”
1 Timothy 3:3
, “not given to filthy lucre.” Some MSS. have not the word so rendered, and the expression has been omitted in the Revised Version.
"LUCRE "from the Lat. lucrum, “gain.” 1 Timothy 3:3, “not given to filthy lucre.” Some MSS. have not the word so rendered, and the expression has been omitted in the Revised Version.


General Information
- Breed Purpose
- Dual Purpose
- Comb
- Single
- Broodiness
- Seldom
- Climate Tolerance
- All Climates
- Egg Productivity
- High
- Egg Size
- Large
- Egg Color
- White
- Breed Temperament
- Less flighty
- Breed Colors/Varieties
- cuckoo
- Breed Size
- Large Fowl
From the Privett website:
"California Greys are a breed cross of Barred Plymouth Rocks and White Leghorns. Mature hens weight is 4.5 pounds. This breed is one of the most efficient white egg producer of breeds or crosses that are not primarily white."
From the Stromberg website:
"The California Gray is a single comb, clean legged variety that originated in the U.S. Developed during the 1930's by crossing White Leghorns with Barred Plymouth Rocks. Great layer of white eggs"
They are said to be among the least flighty of the white laying breeds they are dual purpose. Roosters reach about 5.5 lbs and hens about 4.5
California Gray chick
California Gray hen
California Gray rooster


| Total net profit | -38.31 | Gross profit | 98.41 | Gross loss | -136.72 |
| Profit factor | 0.72 | Expected payoff | -0.55 | ||
| Absolute drawdown | -46.72 | Maximal drawdown (%) | 52.51 (906.91%) | ||
| Total trades | 70 | Profit trades (% of total) | 52 (74.29%) | Loss trades (% of total) | 18 (25.71%) |
| Long positions (won %) | 34 (67.65%) | Short positions (won %) | 36 (80.56%) | ||
| Largest | profit trade | 2.04 | loss trade | -10.52 | |
| Average | profit trade | 1.89 | loss trade | -7.6 | |
| Minimum | profit trade | 1.34 | loss trade | -0.46 | |
| Maximum | take profit in pips | 20.3 | stop loss in pips | -107.6 | |
| Average | take profit in pips | 18.8 | stop loss in pips | -102.2 | |
| Minimum | take profit in pips | 13.4 | stop loss in pips | -100.7 | |
| Maximum | Reward-Risk | 0.2 | Duration in minutes | 6937 | |
| Average | Reward-Risk | 0.2 | Duration in minutes | 1448.8 | |
| Minimum | Reward-Risk | 0.1 | Duration in minutes | 6 | |
| Maximum | consecutive wins (profit in money) | 16.0 (29.68) | consecutive losses (loss in money) | 3.0 (-2.54) | |
| Average | consecutive wins | 3.0 | consecutive losses | 1.0 |
| Total net profit | -31.03 | Gross profit | 43.27 | Gross loss | -74.3 |
| Profit factor | 0.58 | Expected payoff | -0.91 | ||
| Absolute drawdown | -31.03 | Maximal drawdown (%) | 40.35 (432.94%) | ||
| Total trades | 34 | Profit trades (% of total) | 23 (67.65%) | Loss trades (% of total) | 11 (32.35%) |
| Largest | profit trade | 2.04 | loss trade | -10.52 | |
| Average | profit trade | 1.88 | loss trade | -6.75 | |
| Minimum | profit trade | 1.54 | loss trade | -0.46 | |
| Maximum | take profit in pips | 20.3 | stop loss in pips | -105.6 | |
| Average | take profit in pips | 18.8 | stop loss in pips | -102.2 | |
| Minimum | take profit in pips | 15.4 | stop loss in pips | -100.7 | |
| Maximum | Reward-Risk | 0.2 | Duration in minutes | 5962.0 | |
| Average | Reward-Risk | 0.2 | Duration in minutes | 1483.9 | |
| Minimum | Reward-Risk | 0.1 | Duration in minutes | 6.0 | |
| Maximum | consecutive wins (profit in money) | 9.0 (16.89) | consecutive losses (loss in money) | 3.0 (-2.54) | |
| Average | consecutive wins | 2.0 | consecutive losses | 1.0 |
| Total net profit | -7.28 | Gross profit | 55.14 | Gross loss | -62.42 |
| Profit factor | 0.88 | Expected payoff | -0.2 | ||
| Absolute drawdown | -24.67 | Maximal drawdown (%) | 26.63 (1358.67%) | ||
| Total trades | 36 | Profit trades (% of total) | 29 (80.56%) | Loss trades (% of total) | 7 (19.44%) |
| Largest | profit trade | 2.03 | loss trade | -10.52 | |
| Average | profit trade | 1.9 | loss trade | -8.92 | |
| Minimum | profit trade | 1.34 | loss trade | -0.87 | |
| Maximum | take profit in pips | 20.2 | stop loss in pips | -107.6 | |
| Average | take profit in pips | 18.9 | stop loss in pips | -102.1 | |
| Minimum | take profit in pips | 13.4 | stop loss in pips | -100.8 | |
| Maximum | Reward-Risk | 0.2 | Duration in minutes | 6937.0 | |
| Average | Reward-Risk | 0.2 | Duration in minutes | 1415.7 | |
| Minimum | Reward-Risk | Duration in minutes | 15.0 | ||
| Maximum | consecutive wins (profit in money) | 9.0 (16.6) | consecutive losses (loss in money) | 2.0 (-11.39) | |
| Average | consecutive wins | 4.0 | consecutive losses | 1.0 |


Food is any substance[1] consumed to provide nutritional support for the body. It is usually of plant or animal origin, and contains essential nutrients, such as carbohydrates, fats, proteins, vitamins, or minerals. The substance is ingested by an organism and assimilated by the organism's cells to provide energy, maintain life, or stimulate growth.Historically, people secured food through two methods: hunting and gathering and agriculture. Today, the majority of the food energy required by the ever increasing population of the world is supplied by the food industry.Food safety and food security are monitored by agencies like the International Association for Food Protection, World Resources Institute,
World Food Programme, Food and Agriculture Organization, and International Food Information Council. They address issues such as sustainability, biological diversity, climate change, nutritional economics, population growth, water supply, and access to food. The right to food is a human right derived from the International Covenant on Economic, Social and Cultural Rights (ICESCR), recognizing the "right to an adequate standard of living, including adequate food", as well as the "fundamental right to be free from hunger".
Food is any substance[1] consumed to provide nutritional support for the body. It is usually of plant or animal origin, and contains essential nutrients, such as carbohydrates, fats, proteins, vitamins, or minerals. The substance is ingested by an organism and assimilated by the organism's cells to provide energy, maintain life, or stimulate growth.
Some of you will remember the Sainsbury’s advertising campaign from the late 1980s. They all started with "Take" and starred an ingredient that the supermarket wanted to go mainstream. The voiceover was sexy, the dish was easy to make. I had used crème fraîche when I lived in France but I didn’t think its main characteristic – the lovely tangy acidity that balances out its richness – would catch on here.


Generating random bingo sheets using JavaScript and SVG.
Click here to generate a Bingo Card
Note: this only works on Chrome right now.


{% extends 'base.html' %} {% block content %}
{{pitch.description}}
{{pitch.owners}}
{{pitch.technologies}}


#include <lwres/lwres.h>
lwres_result_t
lwres_string_parse
(lwres_buffer_t *b, char **c, lwres_uint16_t *len);
lwres_result_t
lwres_addr_parse
(lwres_buffer_t *b, lwres_addr_t *addr);
lwres_result_t
lwres_getaddrsbyname
(lwres_context_t *ctx, const char *name, lwres_uint32_t addrtypes, lwres_gabnresponse_t **structp);
lwres_result_t
lwres_getnamebyaddr
(lwres_context_t *ctx, lwres_uint32_t addrtype, lwres_uint16_t addrlen, const unsigned char *addr, lwres_gnbaresponse_t **structp);
lwres_string_parse()
retrieves a DNS-encoded
string starting the current pointer of lightweight resolver buffer
b: i.e. b->current
.
When the function returns, the address of the first byte of the
encoded string is returned via *c and the
length of that string is given by *len. The
buffer's current pointer is advanced to point at the character
following the string length, the encoded string, and the trailing
NULL character.
lwres_addr_parse()
extracts an address from the
buffer b. The buffer's current pointer
b->current
is presumed to point at an encoded
address: the address preceded by a 32-bit protocol family identifier
and a 16-bit length field. The encoded address is copied to
addr->address
and
addr->length
indicates the size in bytes of
the address that was copied. b->current
is
advanced to point at the next byte of available data in the buffer
following the encoded address.
lwres_getaddrsbyname()
and
lwres_getnamebyaddr()
use the
lwres_gnbaresponse_t
structure defined below:
typedef struct { lwres_uint32_t flags; lwres_uint16_t naliases; lwres_uint16_t naddrs; char *realname; char **aliases; lwres_uint16_t realnamelen; lwres_uint16_t *aliaslen; lwres_addrlist_t addrs; void *base; size_t baselen; } lwres_gabnresponse_t;The contents of this structure are not manipulated directly but they are controlled through the lwres_gabn(3) functions.
The lightweight resolver uses
lwres_getaddrsbyname()
to perform foward lookups.
Hostname name is looked up using the resolver
context ctx for memory allocation.
addrtypes is a bitmask indicating which type of
addresses are to be looked up. Current values for this bitmask are
LWRES_ADDRTYPE_V4 for IPv4 addresses and
LWRES_ADDRTYPE_V6 for IPv6 addresses. Results of the
lookup are returned in *structp.
lwres_getnamebyaddr()
performs reverse lookups.
Resolver context ctx is used for memory
allocation. The address type is indicated by
addrtype: LWRES_ADDRTYPE_V4 or
LWRES_ADDRTYPE_V6. The address to be looked up is given
by addr and its length is
addrlen bytes. The result of the function call
is made available through *structp.
Successful calls to
lwres_string_parse()
and
lwres_addr_parse()
return
LWRES_R_SUCCESS.
Both functions return
LWRES_R_FAILURE
if the buffer is corrupt or
LWRES_R_UNEXPECTEDEND
if the buffer has less space than expected for the components of the
encoded string or address.
lwres_getaddrsbyname()
returns
LWRES_R_SUCCESS
on success and it returns
LWRES_R_NOTFOUND
if the hostname
name
could not be found.
LWRES_R_SUCCESS
is returned by a successful call to
lwres_getnamebyaddr()
.
Both
lwres_getaddrsbyname()
and
lwres_getnamebyaddr()
return
LWRES_R_NOMEMORY
when memory allocation requests fail and
LWRES_R_UNEXPECTEDEND
if the buffers used for sending queries and receiving replies are too
small.


PODCHECKER
Section: Perl Programmers Reference Guide (1)Updated: 2012-06-22
Index Return to Main Contents
NAME
podchecker - check the syntax of POD format documentation filesSYNOPSIS
podchecker [-help] [-man] [-(no)warnings] [file ...]OPTIONS AND ARGUMENTS
- -help
- Print a brief help message and exit.
- -man
- Print the manual page and exit.
- -warnings -nowarnings
- Turn on/off printing of warnings. Repeating -warnings increases the warning level, i.e. more warnings are printed. Currently increasing to level two causes flagging of unescaped ``<,>'' characters.
- file
- The pathname of a POD file to syntax-check (defaults to standard input).
DESCRIPTION
podchecker will read the given input files looking for POD syntax errors in the POD documentation and will print any errors it find to STDERR. At the end, it will print a status message indicating the number of errors found.Directories are ignored, an appropriate warning message is printed.
podchecker invokes the podchecker() function exported by Pod::Checker Please see ``podchecker()'' in Pod::Checker for more details.
RETURN VALUE
podchecker returns a 0 (zero) exit status if all specified POD files are ok.ERRORS
podchecker returns the exit status 1 if at least one of the given POD files has syntax errors.The status 2 indicates that at least one of the specified files does not contain any POD commands.
Status 1 overrides status 2. If you want unambiguous results, call podchecker with one single argument only.
SEE ALSO
Pod::Parser and Pod::CheckerAUTHORS
Please report bugs using <http://rt.cpan.org>.Brad Appleton<EMAIL_ADDRESS>Marek Rouchal<EMAIL_ADDRESS>Based on code for Pod::Text::pod2text(1) written by Tom Christiansen<EMAIL_ADDRESS>Index
This document was created by man2html, using the manual pages.
Time: 05:29:09 GMT, December 24, 2015


In async programming model, methods do not block the current thread. Instead, an async method returns an Async<Foo>
object, representing an async action running in the background. An Async<Foo>
action eventually completes, either in a success with a Foo
value, or in a failure with an Exception
. For example
static Async<Void> fooAction() { return Fiber.sleep(Duration.ofSeconds(1)); }
Here, Fiber.sleep()
does not block the current thread; instead it immediately returns an Async<Void>
which will complete after some time.
You may use Async.execute()
to convert a legacy blocking action to an async action. For example
Async<byte[]> read(Path filePath) { return Async.execute( ()-> Files.readAllBytes(filePath) ); }
Fiber
is an analogue of Thread
for async actions. A fiber is responsible for executing an async task and sub-tasks. For example
static Async<Integer> task() { ... } public static void main(String[] args) { Fiber<?> fiber = new Fiber<>( ()->task() ); fiber.block(); // block the main thread till task completion }
FiberLocal
is an analogue of ThreadLocal
.
Fiber stack trace
can be enabled, which records execution paths of async actions.
An example usage of Fiber: HttpServer
creates a fiber for each http connection. The fiber executes application code that handles http requests from this connection. FiberLocal
is used to store the current request. Application can dump all fibers to review the state of connections.
After an action completes, often we want to start a subsequent action, and so on. This can be modeled by sequencing methods
like map()
and then()
. For example
Async<Integer> action1(){...} Async<String> action2(Integer x){...} Async<String> sequence = action1() .peek( System.out::println ) .map ( x->x*2 ) .then( x->action2(x) ); // then() is "flat map"
We can also simulate Java's try-catch-finally:
.then( x->action2(x) ) .catch_( IOException.class, e->"default string" ) .finally_( resource::close ) .then( string->... )
AsyncIterator<T>
is an async analogue of Iterator
; it contains a single abstract method
Async<T> next();
which yields the next element asynchronously. The returned Async<T>
eventually succeeds with a T
value as the next element, or fails with an End
exception to end the iteration.
For example, an async iterator that yields ten discrete seconds:
Instant stop = Instant.now().plusSeconds(10); AsyncIterator<Instant> ticks = ()-> { if(Instant.now().isAfter(stop)) return End.async(); // end iteration return Fiber .sleep(Duration.ofSeconds(1)) .map( v -> Instant.now() ); };
An AsyncIterator
can be transformed by map(), filter(),
etc. to create an iterator of new elements:
AsyncIterator<String> iter = AsyncIterator.of(1, 2, 3, 4) .filter(x -> x % 2 == 1) .map( String::valueOf ); // map( T -> R ) AsyncIterator<Instant> ticks2 = AsyncIterator.ofInts(0, 10) .map_( i -> Fiber.sleep(Duration.ofSeconds(1)) ) // map_( T -> Async<R> ) .map ( v -> Instant.now() );
Loops involving async actions can often be modeled by an AsyncIterator
with a terminal operation like forEach(), reduce()
.
Async<Void> p = iter.forEach(System.out::println);
Some async APIs are designed to be compatible with AsyncIterator.next()
. For example, ByteSource.read()
returns Async<ByteBuffer>
, which either succeeds with the next ByteBuffer
, or fails with End
for EOF. It's easy to create an async iterator for the data buffers from the source:
ByteSource source = new FileByteSource("tmp.txt"); AsyncIterator<ByteBuffer> bbs = source::read; bbs.forEach( this::parse ); // 3 alternative ways: ( (AsyncIterator<ByteBuffer>)source::read ).forEach( this::parse ); AsyncIterator.by( source::read ).forEach( this::parse ); AsyncIterator.forEach( source::read, this::parse );
We can run parallel actions and treat them as one collective action, which completes when all or some of the actions complete. See AsyncBundle
. In the following example, we query 3 servers simultaneously, and we only need one successful response from any of the servers:
Async<String> queryServer(int serverId, String term) { ... } Async<String> queryParallel(String term) { Stream<Async<String>> queries = IntStream.range(0, 3) .mapToObj( id -> queryServer(id, term) ); return AsyncBundle.anyOf( queries ); }
You may prefer to formulate an algorithm as functions calling functions... all the way down. If an argument to a function is the eventual success value of an async action, try Async.invoke
String func(boolean arg1, int arg2){ ... } Async<String> x = Async.invoke( this::func, async1(), async2() ); Async<Boolean> async1(){ ... } Async<Integer> async2(){ ... }
Currently Async.invoke
supports only arity of 2, as an experiment. If you are interested in this topic, please provide feedback and let's discuss how to design a more general API.
See Goto and Tail Call on how to program a flowchart containing async actions.
We can send a cancellation request to any async action by action.cancel(reason)
. If the action has not completed yet, it should abort immediately and fail with reason
.
A common usage is to cancel an action after a certain timeout. This can be done conveniently by timeout(duration)
.
queryParallel("kittens").timeout(Duration.ofSeconds(3)) .then( ... )
Promise
is an implementation of Async
for result producers. In the following example, we spawn a thread to do some heavy work asynchronously, using a Promise
to represent the async action. The promise is eventually completed by calling either succeed(value)
or fail(exception)
.
Async<Integer> foo() { Promise<Integer> promise = new Promise<>(); Thread thread = new Thread( ()-> { try { Integer x = someHeavyWork(); promise.succeed(x); } catch(Exception e) { promise.fail(e); } }); thread.start(); promise.onCancel( ex->thread.interrupt() ); return promise; }


(Deprecated API)
(Deprecated API)
(Deprecated API)
Same great maps plus a SLA, support, and control over ads
Note: The Google Maps Javascript API Version 2 has been officially deprecated as of May 19, 2010. The V2 API will continue to work as per our deprecation policy, but we encourage you to migrate your code to version 3 of the Maps Javascript API.
Overlays are objects on the map that are tied to latitude/longitude coordinates, so they move when you drag or zoom the map. Overlays reflect objects that you "add" to the map to designate points, lines, or areas.
The Maps API has several types of overlays:
GMarker
and may make use of the GIcon
type.GPolyline
.GTileLayerOverlay
or even by creating your map type
using a GMapType
.GInfoWindow
attached to a map.Each overlay implements the GOverlay
interface. Overlays
can be added to a map using the GMap2.addOverlay()
method and
removed using the GMap2.removeOverlay()
method. (Note that
the info window is added by default to the map.)
Markers identify points on the map. By default, they use use
G_DEFAULT_ICON
, though you can specify a custom icon. The
GMarker
constructor takes a GLatLng
and an
optional GMarkerOptions
objects as arguments.
Markers are designed to be interactive. By default, they
receive "click"
events, for example, and are often
used within event listeners to bring up info windows.
var map = new GMap2(document.getElementById("map_canvas")); map.setCenter(new GLatLng(37.4419, -122.1419), 13); // Add 10 markers to the map at random locations var bounds = map.getBounds(); var southWest = bounds.getSouthWest(); var northEast = bounds.getNorthEast(); var lngSpan = northEast.lng() - southWest.lng(); var latSpan = northEast.lat() - southWest.lat(); for (var i = 0; i < 10; i++) { var point = new GLatLng(southWest.lat() + latSpan * Math.random(), southWest.lng() + lngSpan * Math.random()); map.addOverlay(new GMarker(point)); }
View example (marker-simple.html)
Markers are interactive objects that can be clicked on and dragged to a new location.
In this example, we place a draggable marker on the map, and listen to a few of its
simpler events. Draggable markers implement four kinds of events: click
,
dragstart
, drag
and dragend
to indicate their drag status.
By default, markers are clickable but not draggable, so they need to be initialized with the
additional marker option draggable
set to true. Draggable markers are
also bouncy by default. If you don't like this behavior, just set the
bouncy
option to false and it will drop down gracefully.
var map = new GMap2(document.getElementById("map_canvas")); var center = new GLatLng(37.4419, -122.1419); map.setCenter(center, 13); var marker = new GMarker(center, {draggable: true}); GEvent.addListener(marker, "dragstart", function() { map.closeInfoWindow(); }); GEvent.addListener(marker, "dragend", function() { marker.openInfoWindowHtml("Just bouncing along..."); }); map.addOverlay(marker);
View example (marker-drag.html)
Markers may define an icon to show in place of the default icon.
Defining an icon is complex because of the number of different images
that make up a single icon in the Maps API. At a minimum, an icon
must define the foreground image, the size of type GSize
,
and an icon offset to position the icon.
The simplest icons are based on the G_DEFAULT_ICON
type. Creating an icon based on this type allows you to quickly
change the default icon by modifying only a few properties.
In the example below, we create an icon using the
G_DEFAULT_ICON
type, and then modify it to
use a different image. (Be careful using different images,
as they need to be set up as the correct size as the default image
to display properly.)
var map = new GMap2(document.getElementById("map_canvas")); map.addControl(new GSmallMapControl()); map.setCenter(new GLatLng(37.4419, -122.1419), 13); // Create our "tiny" marker icon var blueIcon = new GIcon(G_DEFAULT_ICON); blueIcon.image = "http://www.google.com/intl/en_us/mapfiles/ms/micons/blue-dot.png"; // Set up our GMarkerOptions object markerOptions = { icon:blueIcon }; // Add 10 markers to the map at random locations var bounds = map.getBounds(); var southWest = bounds.getSouthWest(); var northEast = bounds.getNorthEast(); var lngSpan = northEast.lng() - southWest.lng(); var latSpan = northEast.lat() - southWest.lat(); for (var i = 0; i < 10; i++) { var point = new GLatLng(southWest.lat() + latSpan * Math.random(), southWest.lng() + lngSpan * Math.random()); map.addOverlay(new GMarker(point, markerOptions)); }
View example (icon-simple.html)
Most icons contain a foreground image and a shadow image. The shadow image should be created at a 45 degree angle (upward and to the right) from the foreground image, and the bottom left corner of the shadow image should align with the bottom-left corner of the icon foreground image.
This example creates a new type of icon, using the
Google Chart API's custom map pins. We have to specify a foreground image, the shadow image, and the points at
which we anchor the icon to the map and anchor the info window to the icon. Note that
the icon is passed in options defined in the GMarkerOptions
object.
var map = new GMap2(document.getElementById("map")); map.addControl(new GSmallMapControl()); map.addControl(new GMapTypeControl()); map.setCenter(new GLatLng(37.4419, -122.1419), 13); // Create our "cafe" marker icon var cafeIcon = new GIcon(); cafeIcon.image = "http://chart.apis.google.com/chart?chst=d_map_pin_icon&chld=cafe|996600"; cafeIcon.shadow = "http://chart.apis.google.com/chart?chst=d_map_pin_shadow"; cafeIcon.iconSize = new GSize(12, 20); cafeIcon.shadowSize = new GSize(22, 20); cafeIcon.iconAnchor = new GPoint(6, 20); cafeIcon.infoWindowAnchor = new GPoint(5, 1); // Set up our GMarkerOptions object literal markerOptions = { icon:cafeIcon }; // Add 10 markers to the map at random locations var bounds = map.getBounds(); var southWest = bounds.getSouthWest(); var northEast = bounds.getNorthEast(); var lngSpan = northEast.lng() - southWest.lng(); var latSpan = northEast.lat() - southWest.lat(); for (var i = 0; i < 10; i++) { var point = new GLatLng(southWest.lat() + latSpan * Math.random(), southWest.lng() + lngSpan * Math.random()); map.addOverlay(new GMarker(point, markerOptions)); }
Note that the definition of the GMarkerOptions
objects demonstrates usage of object literal
notation. The object is not instantiated using a constructor; instead, it is simply
declared using name-value pairs.
View example (icon-complex.html)
For more information about using the Chart API HTTP Service,
check out this
Group posting. To create more complex icons, you may also be interested
in the
MapIconMaker
and its associated
MarkerIconOptions
Wizard.
GIcon
objects also have several other properties
that you should set to get maximum browser compatibility and
functionality from your icons. For example, the imageMap
property specifies the shape of the non-transparent parts of the
icon image. If you do not set this property in your icon, the entire
icon image (including the transparency) will be clickable in
Firefox/Mozilla. See the GIcon class
reference for more information.
In many cases, your icons may have different foregrounds, but the same shape
and shadow. The easiest way to achieve this behavior is to use the copy constructor
for the GIcon
class, which copies all the properties over to a new icon
which you can then customize.
var map = new GMap2(document.getElementById("map_canvas")); map.addControl(new GSmallMapControl()); map.addControl(new GMapTypeControl()); map.setCenter(new GLatLng(37.4419, -122.1419), 13); // Create a base icon for all of our markers that specifies the // shadow, icon dimensions, etc. var baseIcon = new GIcon(G_DEFAULT_ICON); baseIcon.shadow = "http://www.google.com/mapfiles/shadow50.png"; baseIcon.iconSize = new GSize(20, 34); baseIcon.shadowSize = new GSize(37, 34); baseIcon.iconAnchor = new GPoint(9, 34); baseIcon.infoWindowAnchor = new GPoint(9, 2); // Creates a marker whose info window displays the letter corresponding // to the given index. function createMarker(point, index) { // Create a lettered icon for this point using our icon class var letter = String.fromCharCode("A".charCodeAt(0) + index); var letteredIcon = new GIcon(baseIcon); letteredIcon.image = "http://www.google.com/mapfiles/marker" + letter + ".png"; // Set up our GMarkerOptions object markerOptions = { icon:letteredIcon }; var marker = new GMarker(point, markerOptions); GEvent.addListener(marker, "click", function() { marker.openInfoWindowHtml("Marker <b>" + letter + "</b>"); }); return marker; } // Add 10 markers to the map at random locations var bounds = map.getBounds(); var southWest = bounds.getSouthWest(); var northEast = bounds.getNorthEast(); var lngSpan = northEast.lng() - southWest.lng(); var latSpan = northEast.lat() - southWest.lat(); for (var i = 0; i < 10; i++) { var point = new GLatLng(southWest.lat() + latSpan * Math.random(), southWest.lng() + lngSpan * Math.random()); map.addOverlay(createMarker(point, i)); }
View example (icon-custom.html)
Adding a large number of markers to a Google map may both slow down rendering of the map and introduce too much visual clutter, especially at certain zoom levels. The marker manager utility provides a solution to both of these issues, allowing efficient display of hundreds of markers on the same map and the ability to specify at which zoom levels markers should appear.
The marker manager utility is provided within the
GMaps Utility Library.
This library is open source, and contains utilities that are not part of the core Google
Maps API. To add utilities contained within this library, you add the JavaScript source
directly with a <script>
tag.
<script src="http://gmaps-utility-library.googlecode.com/svn/trunk/markermanager/release/src/markermanager.js">
The MarkerManager
object within the markermanager.js
library
offloads management of markers registered with the utility, keeping
track of which markers are visible at certain zoom levels within the current view, and
passing only these markers to the map for drawing purposes. The manager monitors the map's
current viewport and zoom level, dynamically adding or removing markers from the map as
they become active. In addition, by allowing markers to specify the zoom levels at which
they display themselves, developers can implement marker clustering. Such management can
greatly speed up map rendering and reduce visual clutter.
To use a marker manager, create a MarkerManager
object. In the
simplest case, just pass a map to it.
var map = new GMap2(document.getElementById("map_canvas")); map.setCenter(new GLatLng(41, -98), 4); var mgr = new MarkerManager(map);
You may also specify a number of options to fine-tune the marker
manager's performance. These options are passed via a
MarkerManagerOptions
object, which contains the following fields:
maxZoom
: specifies the maximum zoom level monitored by
this marker manager. The default value is the highest zoom level supported by Google maps.borderPadding
: specifies the extra padding, in pixels,
monitored by the manager outside the current viewport. This allows for
markers just out of sight to be displayed on the map, improving panning
over small ranges. The default value is 100.trackMarkers
: specifies whether movement of movements
of markers should be tracked by the marker manager. If you wish to have
managed markers that change their positions through the setPoint()
method, set this value to true
. By default, this flag
is set to false
. Note that if you move markers with this
value set to false
, they will appear in both the original
location and the new location(s).The MarkerManagerOptions
object is an object literal, so you
simply declare the object without a constructor:
var map = new GMap2(document.getElementById("map_canvas")); var mgrOptions = { borderPadding: 50, maxZoom: 15, trackMarkers: true }; var mgr = new MarkerManager(map, mgrOptions);
Once you create a manager, you will want to add markers to it.
MarkerManager
supports adding single markers one at a
time using the addMarker()
method or a collection passed
as an array using the addMarkers()
method. Single markers
added using addMarker()
will appear immediately on the map
provided that they fall within the current view and specified zoom
level constraints.
Adding markers collectively using addMarkers()
is
recommended as it is more efficient. Markers added using the
addMarkers()
method will not appear on the map until
you explicitly call the MarkerManager
's
refresh()
method, which adds all markers within the
current viewport and border padding region to the map. After this
initial display, MarkerManager
takes care of all
visual updates by monitoring the map's "moveend" events.
The following example creates a mock weather map for Europe. At zoom level 3, 20 randomly distributed weather icons are displayed. At level 6, when all 200 cities with population over 300,000 are easily distinguished, an additional 200 markers are shown. Finally, at level 8, 1000 markers are shown. (Note: to simplify the example, markers will be added at random locations.)
function setupMap() { if (GBrowserIsCompatible()) { map = new GMap2(document.getElementById("map_canvas")); map.addControl(new GLargeMapControl()); map.setCenter(new GLatLng(41, -98), 4); window.setTimeout(setupWeatherMarkers, 0); } } function getWeatherMarkers(n) { var batch = []; for (var i = 0; i < n; ++i) { batch.push(new GMarker(getRandomPoint(), { icon: getWeatherIcon() })); } return batch; } function setupWeatherMarkers() { mgr = new MarkerManager(map); mgr.addMarkers(getWeatherMarkers(20), 3); mgr.addMarkers(getWeatherMarkers(200), 6); mgr.addMarkers(getWeatherMarkers(1000), 8); mgr.refresh(); }
View example (weather_map.html)
The marker manager can also perform simple clustering of markers. While it does not do so automatically, you can achieve the desired effect by setting both the minimum and maximum zoom at which a given marker is shown. In this example we create a map of Google offices in North America. At the highest level we show flags of countries in which offices are located. For zoom levels 3 to 7 we show icons over population centers where one or more offices are located. Finally, at levels 8 or higher, we show individual markers for each office.
var officeLayer = [ { "zoom": [0, 3], "places": [ { "name": "US Offices", "icon": ["us", "flag-shadow"], "posn": [40, -97] }, { "name": "Canadian Offices", "icon": ["ca", "flag-shadow"], "posn": [58, -101] } ] }, ... }; function setupOfficeMarkers() { var mgr = new MarkerManager(map); for (var i in officeLayer) { var layer = officeLayer[i]; var markers = []; for (var j in layer["places"]) { var place = layer["places"][j]; var icon = getIcon(place["icon"]); var posn = new GLatLng(place["posn"][0], place["posn"][1]); markers.push(new GMarker(posn, { title: place["name"], icon: icon })); } mgr.addMarkers(markers, layer["zoom"][0], layer["zoom"][1]); } mgr.refresh(); }
View example (google_northamerica_offices.html)
For more information, see the reference documentation for the Open Source Marker Manager.
GPolyline
objects create a linear overlay on the map. A
GPolyline
consists of a series of points and creates a series
of line segments that connect those points in an ordered sequence.
Polylines are drawn as a series of straight segments on the map. You can specify
custom colors, weights, and opacities for the line. Colors should be in hexadecimal
numeric HTML style, e.g., use #ff0000
instead of red
.
GPolyline
does not understand named colors.
GPolyline
objects use the vector drawing capabilities
of the browser, if available. In Internet Explorer, Google Maps uses
VML (see XHTML and VML) to draw polylines;
in other browsers SVG is used if available. In all other circumstances, we request an
image of the line from Google servers and overlay that image on the
map, refreshing the image as necessary as the map is zoomed and dragged around.
The following code snippet creates a 10-pixel-wide red polyline between two points:
var polyline = new GPolyline([ new GLatLng(37.4419, -122.1419), new GLatLng(37.4519, -122.1519) ], "#ff0000", 10); map.addOverlay(polyline);
View example (polyline-simple.html)
Polylines represented on the map are straight lines conforming to the
current projection. That is, they appear straight on the map, but may in fact
not properly account for the curvature of the earth. If you instead wish
to draw a geodesic (a segment of a "great circle" representing the shortest
distance between two points on the surface of the earth), you
will need to pass geodesic:true
in the GPolylineOptions
argument of the GPolyline
.
The GPolylineOptions
object is an example of an object literal.
With object literals, you don't construct an object. Instead, you pass
the arguments as a series of name/value pairs within curly brackets.
Object literals are used often in those cases where instantiating an
object is unnecessary.
var map = new GMap2(document.getElementById("map_canvas")); map.setCenter(new GLatLng(45.828799,-105.292969), 2); // Create GPolylineOptions argument as an object literal. // Note that we don't use a constructor. var polyOptions = {geodesic:true}; var polyline = new GPolyline([ new GLatLng(40.65642, -73.7883), new GLatLng(61.1699849, -149.944496) ], "#ff0000", 10, 1, polyOptions); map.addOverlay(polyline);
View example (polyline-geodesic.html)
The GPolyline
object within a Google map denotes a line as a
series of points, making it easy to use but not necessarily compact. Long and
complicated lines require a fair amount of memory, and often may take longer to
draw. Also, the individual segments within an unencoded polyline are drawn on the
map regardless of their resolution at larger zoom levels.
The Google Maps API allows you to represent paths using encoded polylines,
which specify a series of points within a GPolyline
using a
compressed format of ASCII characters. The encoded polyline also allows you
to specify groups of zoom levels that should be ignored when drawing line
segments; doing so allows you to specify how detailed a polyline should be
at a given zoom level. Although more difficult to set up, encoded polylines
can make your overlays draw much more efficiently.
For example, a GPolyline
of 3 points (2 line segments) is normally represented as:
var polyline = new GPolyline([ new GLatLng(37.4419, -122.1419), new GLatLng(37.4519, -122.1519), new GLatLng( 37.4619, -122.1819) ], "#FF0000", 10); map.addOverlay(polyline);
An encoded GPolyline
of these same points appears below
(for now, don't worry about particulars of the encoding algorithm).
var encodedPolyline = new GPolyline.fromEncoded({ color: "#FF0000", weight: 10, points: "yzocFzynhVq}@n}@o}@nzD", levels: "BBB", zoomFactor: 32, numLevels: 4 }); map.addOverlay(encodedPolyline);
There are two things to notice about this code.
GPolyline
. The algorithm for creating these points as a
series of encoded ASCII values is documented
here. This algorithm is needed if you wish to calculate encoded polylines
on the fly via a server process, for example. However, if you just wish to
convert existing points given latitudes and longitudes, you can use our
interactive utility.
GPolyline
s and is especially useful for allowing fast drawing at high zoom
levels, where the details of some line segments may not be relevant. For example, an encoded polyline
representing a drive from New York City to Chicago should not care about the line segments representing
particular streets in Manhattan when the map is zoomed out to the state level.
View example (polyline-encoding.html)
Interactive Encoded Polyline Utility
See Polyline algorithm for information on the underlying encoded polyline algorithm.
GPolygon
objects are similar to GPolyline
objects
in that they consist of a series of points in an ordered sequence. However,
instead of being open-ended, polygons are designed to define regions within a
closed loop. As with polylines, you can define custom colors, weights, and
opacities for the edge of the polygon (the "line") and custom colors and
opacities for the fill area within the enclosed region. Colors should be
in hexadecimal numeric HTML style.
GPolygon
objects, like GPolyline
objects, use
the vector drawing capabilities of the browser, if available.
The following code snippet creates a 10-pixel-wide box around four points. Note that this polygon is "closed" by returning the segment path to its initial point; you should always close polygons to avoid undefined behavior.
var map = new GMap2(document.getElementById("map_canvas")); map.setCenter(new GLatLng(37.4419, -122.1419), 13); map.addControl(new GSmallMapControl()); GEvent.addListener(map, 'click', function(overlay, latlng) { var lat = latlng.lat(); var lon = latlng.lng(); var latOffset = 0.01; var lonOffset = 0.01; var polygon = new GPolygon([ new GLatLng(lat, lon - lonOffset), new GLatLng(lat + latOffset, lon), new GLatLng(lat, lon + lonOffset), new GLatLng(lat - latOffset, lon), new GLatLng(lat, lon - lonOffset) ], "#f33f00", 5, 1, "#ff0000", 0.2); map.addOverlay(polygon); });
View example (polygon-simple.html)
Polygons are useful overlays to represent arbitrarily-sized areas, but they
cannot display images. If you have an image that you wish to place on a map,
you can use a GGroundOverlay
object. The constructor for a
GGroundOverlay
a URL of an image and the GLatLngBounds
of the image
as parameters.
The following example places an antique map of Newark, NJ on the map as an overlay:
var map = new GMap2(document.getElementById("map_canvas")); map.setCenter(new GLatLng(40.740, -74.18), 12); // ground overlay var boundaries = new GLatLngBounds(new GLatLng(40.716216,-74.213393), new GLatLng(40.765641,-74.139235)); var oldmap = new GGroundOverlay("http://www.lib.utexas.edu/maps/historical/newark_nj_1922.jpg", boundaries); map.addControl(new GSmallMapControl()); map.addControl(new GMapTypeControl()); map.addOverlay(oldmap);
View example (groundoverlay-simple.html)
The map within the Google Maps API consist of a set of tiles,
covering the entire surface of the earth, at each zoom level. Tiles
exist for each map type in use: G_NORMAL_MAP
,
G_SATELLITE_MAP
, G_HYBRID_MAP
, and
G_PHYSICAL_MAP
.
Tiles do not cover all regions at all zoom levels. Different areas of the map may contain tiles at varying resolutions, and therefore varying zoom levels. As a result, tile coverage of any map type varies based on location. Many areas of the Pacific Ocean do not appear at high zoom levels, for example, while Manhattan may have very detailed satellite images.
At the lowest zoom level (level 0), one tile represents the entire earth:
Each succeeding zoom level divides the map into 4 N tiles, where N refers to the zoom level. For example, at zoom level 1, Google Maps divides the world up into a 2x2 grid for a total of 4 tiles; at zoom level 2, Google Maps divides up the world into a 4x4 grid for a total of 16 tiles, etc.
For satellite map types (map types of G_SATELLITE_MAP
and
G_HYBRID_MAP
), you can determine the maximum zoom level where
satellite images are available at a particular location using the
GMapType.getMaxZoomAtLatLng()
method.
The following example captures user clicks, and determines the highest zoom level for satellite imagery at that location. Note that you don't need to be viewing a satellite map to determine the maximum zoom level.
var map; function initialize() { if (GBrowserIsCompatible()) { map = new GMap2(document.getElementById("map_canvas")); map.setCenter(new GLatLng(55.366625,-131.660156), 7); map.setMapType(G_SATELLITE_MAP); map.setUIToDefault(); GEvent.addListener(map, 'click', function(overlay, latlng) { showMaxZoom(latlng); }); } } function showMaxZoom(latlng) { G_SATELLITE_MAP.getMaxZoomAtLatLng(latlng, function(response) { if (response && response['status'] == G_GEO_SUCCESS) { alert("The maximum zoom level where satellite imagery is available at this location is: " + response['zoom']); } }); }
View example (map-maxzoom.html)
If you wish to modify display of map tiles, you have two options:
GTileLayerOverlay
GMapType
The first case is much simpler but is more limited in usage, while the second case allows you more control over display within your application. Each case is discussed below, although full implementation of a custom map type is not covered in this documentation.
Each case requires you to implement three abstract methods from the
GTileOverlay
interface:
getTileUrl()
returns to the map a URL containing the tile image, given
a passed GPoint
and zoom level.isPng()
returns to the map a Boolean
indicating whether the image
is a PNG file (which can be displayed transparently). If true
, the image
is assumed to be a PNG.getOpacity()
returns a value between 0.0 and 1.0 indicating the level
of opacity to display this image.We will discuss the different approaches in the next two sections.
If you want an overlay to appear on an existing map type, use the
GTileLayerOverlay
object. This object requires you to
create a GCopyrightCollection
and attach it to the
tile layer to indicate permission for use of the image or images.
The following code displays a simple transparent overlay on each tile at all zoom levels, denoting the outline of the tiles between floating crosshairs.
// Set up the copyright information // Each image used should indicate its copyright permissions var myCopyright = new GCopyrightCollection("© "); myCopyright.addCopyright(new GCopyright('Demo', new GLatLngBounds(new GLatLng(-90,-180), new GLatLng(90,180)), 0,'©2007 Google')); // Create the tile layer overlay and // implement the three abstract methods var tilelayer = new GTileLayer(myCopyright); tilelayer.getTileUrl = function() { return "../include/tile_crosshairs.png"; }; tilelayer.isPng = function() { return true;}; tilelayer.getOpacity = function() { return 1.0; } var myTileLayer = new GTileLayerOverlay(tilelayer); var map = new GMap2(document.getElementById("map_canvas")); map.setCenter(new GLatLng(37.4419, -122.1419), 13); map.addOverlay(myTileLayer);
View example (tileoverlay-simple.html)
Note: This is an Advanced Topic
If you find the GTileLayerOverlay
too limiting,
you can define your own custom map type, and develop an entirely new
display paradigm. To do so, construct a GMapType
object
and add it to the map using the GMap2.addMapType()
method.
Constructing a map type from scratch is an involved process. You will need to build a way to define and retrieve dynamic data to display on the map given current coordinates, and you will need to determine yourself how to reference and display tile images. How you do that is up to you; however, we can help you a little by explaining how Google Maps implements its tile references.
There are three coordinate systems that the Google Maps API uses:
Each system is discussed below.
Each tile within Google Maps consists of 256 x 256 pixels. A point on a
particular tile can therefore be referenced using a GPoint
x,y
pair. The origin (0,0)
for each tile is denoted at the
northwest corner of the tile. Therefore, for the single tile which represents
the entire earth, the origin is set to lie at the North Pole and -180 degrees
longitude, where you see Alaska. x
(longitude) values increase
east, while y
(latitude) values increase south to the
the southeast point (255,255)
.
At higher zoom levels, the pixel space expands by doubling in both the x and y directions. For example, at zoom level 1, the map consists of 4 256x256 pixels tiles, resulting in a pixel space from 512x512. At zoom level 19, each x and y pixel on the map can be referenced using a value between 0 and 256 * 219.
Referencing such a point uniquely on the entire map is often not practical. At higher zoom levels, the Google Maps API could not use one image file to display the entire earth. It is therefore useful to determine which image tile is in use, and then compute the pixel coordinate relative to the origin of that tile. Any custom map you implement will need to do the same evaluation.
Tiles in Google Maps are numbered from the same origin as that for
pixels, so that the origin tile is always at the northwest corner
of the map. Tiles are indexed using x,y
coordinates
from that origin. For example, at zoom level 2, when the earth
is divided up into 16 tiles, each tile can be referenced by a
unique x,y
pair:
Indexing a particular point on a particular zoom level can therefore use two
GPoint
values: one to reference the tile in usage, and one to
reference the coordinate within the tile's pixel on that 256 x 256 image.
Implementing a tile overlay for other than a few simple zoom levels can
be an onerous task, as you would need to add logic to determine which
particular tile image to serve. The Google Maps API allows you to construct
a GTileLayer
passing a GTileLayerOptions
argument
as an object literal. The GTileLayerOptions
argument contains
a tileUrlTemplate
property that maps tile requests to URLs
based on tile coordinates. The constructor for an overlay would look something
like this:
var tileLayerOverlay = new GTileLayerOverlay( new GTileLayer(null, null, null, { tileUrlTemplate: 'http://domain.com/myimage_{Z}_{X}_{Y}.png', isPng:true, opacity:1.0 }) ); map.addOverlay(tlo);
This template scheme allows you to address a collection of tile images named using tile coordinates as they are done within Google Maps.
Maps usually have imagery which is either purchased, generated or licensed from some external entity. Those images often require copyright information to be displayed, and in certain cases (such as satellite data), the imagery may come from different sources at different locations on the map. In order to provide the ability to display dynamic copyright information on your custom map types, the Maps API provides a number of objects to hold copyright information, and provides methods and interfaces for implementing retrieval of this copyright information based on the current viewport and zoom level.
The GCopyright
object is a simple object that holds basic copyright
information. This object's minZoom
and bounds
properties define the constraints under which this copyright information is valid
with text
containing the copyright string to display under those
conditions.
Sets of GCopyright
objects are collected into a
GCopyrightCollection
. The GCopyrightCollection
constructor
allows you to define a text prefix (such as "Imagery © 2007") to attach to all
copyright notices. Note that you cannot add copyrights to the GCopyrightCollection
directly within the constructor. You must call the addCopyright
method to add individual GCopyright
objects to the collection after it is
constructed.
The GTileLayer
interface requires a copyrights
argument
in its constructor. Classes which handle these tile layers
(such as GTileLayerOverlay
and GMapType
) need to create a
GCopyrightCollection
object beforehand and pass that object to the
constructor of the tile layer.
The Google Maps API implements the following methods for displaying copyright information, which you may override to provide custom behavior:
GMapType.getCopyrights()
invokes GTileLayer.getCopyright()
on all its child tile layers.GTileLayer.getCopyright()
invokes GCopyrightCollection.getCopyrightNotice()
on its copyright collection.GCopyrightCollection.getCopyrightNotice()
returns the copyright notice(s) attached to
this object, checking whether the given bounds
and zoom
applies to
each of its child GCopyright
objects.Each of these methods contains bounds
and zoom
parameters
which you can override and inspect to decide what copyright information to display.
By default, whenever the Google Maps API displays a tile layer within a map type,
it retrieves the current copyrights in use via the GTileLayer.getCopyright()
method. Some map types may include multiple tile layers, which may mean that information from
multiple GCopyrightCollection
objects may need to be displayed concurrently.
(The G_HYBRID_MAP
map type implements both a satellite layer and a map layer,
for example.) This concurrent information is displayed by concatenating copyright notices
from multiple copyright collections.
The earth is a sphere, while a map is a flat two-dimensional object. The map
that you see within the Google Maps API is a projection of that sphere onto
a flat surface. Projections in the Google Maps API are implemented using the
GProjection
interface. Only one projection is currently
implemented in the Google Maps API: GMercatorProjection
. In
its simplest terms, a projection can be defined as a one-to-one
correspondence of GLatLng
values into coordinates on the map
and the GProjection
interface provides conversion utilities
for this purpose.
The GProjection.fromLatLngToPixel()
method converts a
GLatLng
value into a pixel coordinate at the given zoom level.
Similarly, the GProjection.fromPixelToLatLng()
method converts
a pixel coordinate at a given zoom level into a GLatLng
value.
These methods are useful when implementing a map type, as they allow you
to determine which tiles to show, how to display them, and at what offset
to display them.
The following example handles click events by calculating the pixel coordinates at the current zoom level, and returns both the pixel coordinates and tile coordinates for that location:
View example (tile-detector.html)
For more information about implementing map types, consult the GMapType reference.
GLayer
objects are overlay objects that store a set of
third-party geographic information. Layers are sets of
geographically-related features that share some common function, and are
displayed on a map as a group. Google provides these sets from
data obtained from other sources, and bundles them together within a
a single layer.
Layers generally consist of a variety of items — typically markers,
polylines, and polygons — though they are not considered separate objects.
The layer itself (and all of its components) is considered a single overlay
to the Maps API, and is added to the map via the standard
addOverlay()
method. The layer may also be interactive,
allowing actions on components to bring up info windows, for example.
Layers each contain a unique namespace ID so that they can be easily
referenced and addressed uniquely. This namespace ID is currently based on the
domain of the source layer. The English Geotagged Wikipedia ©
Articles layer, for example, has a namespace ID of
"org.wikipedia.en
".
The Google Maps API currently has access to these public layers. New layers will periodically be added to the Maps API. We will maintain this list at this spreadsheet.
The following code snippet adds an English Wikipedia layer to Greenwich Village, New York City:
function initialize() { if (GBrowserIsCompatible()) { var map = new GMap2(document.getElementById("map_canvas")); map.setCenter(new GLatLng(40.730885,-73.997383), 15); var myLayer = new GLayer("org.wikipedia.en"); map.addOverlay(myLayer); } }
View example (layer-simple.html)
The Google Maps API also allows you to create custom
overlay objects by implementing the GOverlay
interface. The Google Maps
API provides several services, such as GTrafficOverlay
,GGeoXml
,
and GStreetviewPanorama
objects, through implementation of the
GOverlay
interface. (These services
are documented in the Services section.)
The GOverlay
interface requires you to implement four abstract methods:
initialize()
called in response to GMap2.addOverlay()
remove()
called in response to GMap2.removeOverlay()
copy()
to allow templating of the new overlayredraw()
called in response to a display change within the mapGoogle Maps API interfaces are implemented within JavaScript through assignment of the
prototype
property to an instance of the inherited object.
For example, a Rectangle
object inherits from the
GOverlay
interface using the following code:
OverlaySubclass.prototype = new GOverlay();
Implementation of the abstract methods in the GOverlay
interface
is facilitated through assignment of these methods on the object's
prototype
:
OverlaySubclass.prototype.initialize = myInitializeMethod; OverlaySubclass.prototype.remove = myRemoveMethod; OverlaySubclass.prototype.copy = myCopyMethod; OverlaySubclass.prototype.redraw = myRedrawMethod;
In the following example, we create a Rectangle
overlay that outlines
a geographic region on the map. The Rectangle
class defines the
four required methods of the GOverlay
interface. Specifically,
make note of the initialize()
method, which creates the DOM elements
representing our overlay, and the redraw()
method, which positions
and sizes the overlay on the map based on the current projection and zoom level.
Every DOM element that makes up an overlay exists on a map pane
that defines the z-order at which it will be drawn. For example, polylines
are flat against the map, so they are drawn in the lowest G_MAP_MAP_PANE
.
Markers place their shadow elements in the G_MAP_MARKER_SHADOW_PANE
and their foreground elements in the G_MAP_MARKER_PANE
.
Placing your overlay elements in the correct panes ensures that polylines are
drawn below marker shadows and the info window is drawn above other overlays
on the map. In this example, our overlay is flat against the map, so we
add it to the lowest z-order pane G_MAP_MAP_PANE
, just like
GPolyline
. See the class reference
for a complete list of map panes.
// A Rectangle is a simple overlay that outlines a lat/lng bounds on the // map. It has a border of the given weight and color and can optionally // have a semi-transparent background color. function Rectangle(bounds, opt_weight, opt_color) { this.bounds_ = bounds; this.weight_ = opt_weight || 2; this.color_ = opt_color || "#888888"; } Rectangle.prototype = new GOverlay(); // Creates the DIV representing this rectangle. Rectangle.prototype.initialize = function(map) { // Create the DIV representing our rectangle var div = document.createElement("div"); div.style.border = this.weight_ + "px solid " + this.color_; div.style.position = "absolute"; // Our rectangle is flat against the map, so we add our selves to the // MAP_PANE pane, which is at the same z-index as the map itself (i.e., // below the marker shadows) map.getPane(G_MAP_MAP_PANE).appendChild(div); this.map_ = map; this.div_ = div; } // Remove the main DIV from the map pane Rectangle.prototype.remove = function() { this.div_.parentNode.removeChild(this.div_); } // Copy our data to a new Rectangle Rectangle.prototype.copy = function() { return new Rectangle(this.bounds_, this.weight_, this.color_, this.backgroundColor_, this.opacity_); } // Redraw the rectangle based on the current projection and zoom level Rectangle.prototype.redraw = function(force) { // We only need to redraw if the coordinate system has changed if (!force) return; // Calculate the DIV coordinates of two opposite corners of our bounds to // get the size and position of our rectangle var c1 = this.map_.fromLatLngToDivPixel(this.bounds_.getSouthWest()); var c2 = this.map_.fromLatLngToDivPixel(this.bounds_.getNorthEast()); // Now position our DIV based on the DIV coordinates of our bounds this.div_.style.width = Math.abs(c2.x - c1.x) + "px"; this.div_.style.height = Math.abs(c2.y - c1.y) + "px"; this.div_.style.left = (Math.min(c2.x, c1.x) - this.weight_) + "px"; this.div_.style.top = (Math.min(c2.y, c1.y) - this.weight_) + "px"; } var map = new GMap2(document.getElementById("map")); map.addControl(new GSmallMapControl()); map.addControl(new GMapTypeControl()); map.setCenter(new GLatLng(37.4419, -122.1419), 13); // Display a rectangle in the center of the map at about a quarter of // the size of the main map var bounds = map.getBounds(); var southWest = bounds.getSouthWest(); var northEast = bounds.getNorthEast(); var lngDelta = (northEast.lng() - southWest.lng()) / 4; var latDelta = (northEast.lat() - southWest.lat()) / 4; var rectBounds = new GLatLngBounds( new GLatLng(southWest.lat() + latDelta, southWest.lng() + lngDelta), new GLatLng(northEast.lat() - latDelta, northEast.lng() - lngDelta)); map.addOverlay(new Rectangle(rectBounds));


Welcome to Arcade Game
How To Play
Use the arrow keys to move your player
Winning
Reach the water to earn three points
Collect gems to earn one point
Earn ten points to win the game
Losing
Hitting a rock loses a point
Hitting a bug loses a life
Having negative points or lives loses the game
Click to Select a Character
Click Here to Start Playing!
Lives: 4
Score: 0


Routine Maintenance for all your splits, Cassette’s, Ducted AC, Package Unit, VRV & Chillers and Servicing for all brands of AC with varied Tonnage
Comprehensive, Non comprehensive, and Labour only.
Lorem ipsum dolor sit amet, consectetur adipisicing elit. Minima maxime quam architecto quo inventore harum ex magni, dicta impedit.
Our Client Base Sprawls Over A Wide Range Of Sectors:


Morbi leo risus, porta ac consectetur ac, vestibulum at eros. Maecenas sed diam eget risus varius bladit sit amet non
You should totally sign up for our super awesome service. It's what all the cool kids are doing nowadays.
To reset your password enter your email and your birthday and we'll send you a link to reset your password.


@(currentUser: User,
mostRecentModules: List[Module],
highestRatedModules: List[Module],
featuredModules: List[FeaturedModule])
@import tags._
@main("Home", currentUser) {
Here you can find great modules contributed by the play community. Browse the catalog and add instant power to your application.
Play 2.x modules and Play 1.x modules.
Featured , Latest , Highest-rated,
Check out the source code on Github.
Play framework
modules for
Play 2.x and Play 1.x
Browse modules
Contribute
Get involved


{% extends "base.html" %} {% load staticfiles %} {% block page_head %} {% endblock %} {% block page_content %} Toggle navigation Eli & Lucy Wedding Location Gifts {% block main %} Lucy & Eli 8.8.2020 We're getting married! Saturday, August 8, 2020 at 11 am The Laurelhurst Club in southeast Portland Wedding Portland & The Laurelhurst Club {% include 'partials/wedding.html' %} {% include 'partials/location.html' %} {% include 'partials/gifts.html' %} {% endblock %} {% endblock %} {% block page_js %} {% endblock %}
Saturday, August 8, 2020 at 11 am The Laurelhurst Club in southeast Portland


Start Video
Stop Video
Start audio
Stop audio
Start screen share
Stop screen share
Start recording
Stop recording
You are logged out.
Not Recording
Participant Name :
Enter your name
Conference alias :
Enter a unique conference name
Join
Leave
Participants


Thanks for subscribing, and welcome to the 1st edition of AI for Trust, Safety and Fraud, your monthly guide to the latest insights on machine learning for trust, safety, fraud detection, and risk management. My goal with this newsletter is to share valuable knowledge, updates, and resources to help you stay informed and empowered in this rapidly evolving field.
In this edition of our newsletter, we'll navigate through three main sections. We'll first delve into Current Affairs, exploring some latest news in fraud and security. Then, we'll revisit some of the past insights from the blogposts - 'Fraud Detection Systems 101 and Beyond'. And finally, we'll shine the spotlight on a recent research piece in the field of mobile social network fraud detection. I will always be looking for ways to improve, so don't hesitate to share your feedback or suggestions. This would help in ensuring that you continue getting valuable content that serves your interests. Let's dive in!
|
|
1. Current Affairs
Payments Fraud and Control Survey - J.P. Morgan
The latest (2023) Payments Fraud and Control Survey that is sponsored by J.P. Morgan for over 15 years is out, and following are the key insights:
- Payments fraud is still a serious threat for every organization. The share of businesses that report commercial card fraud has increased by 10 percentage points since 2021.
- Over half of organizations with annual revenue of less than $1 billion were unable to recover funds lost due to payment fraud attacks.
- Fraudsters continue to impersonate employees and vendors through sophisticated business email compromise (BEC) schemes that are the root cause of most reported fraud cases.
- Checks continue to be the payment method most vulnerable to fraud. Still, three of our four organizations that use checks plan to keep using checks.
- Business Email Compromises (BEC) scams are still highly prevalent and are the root cause of payments fraud at a majority of organizations. 71% of companies were victims of payments fraud via email in 2022. Payment methods often used during BEC included wires, (45% respondents) and ACH debits.
|
|
The meta-owned WhatsApp app is ramping up to provide several privacy and safety tools to proactively weed out bad actors from the platform. This month, WhatsApp introduced features to tackle spam calls which are highly prevalent in India - Tech Crunch. India is the biggest market for WhatsApp with over 500 million users. Based on user's reports, these spam calls promote fraudulent job offers and originate from international codes from countries including Ethiopia (+251), Indonesia (+62), Kenya (+254), Malaysia (+60) and Vietnam (+84), among others.
2022 U.S Spam and Scam - Truecaller
Continuing the discussion of spam calls, some insights from 2022 U.S Spam and Scam Report published by Truecaller (yeah, not really a current news in 2023):
Phone scams are relentless and the numbers don’t lie. A staggering $39.5 billion USD (extrapolation based on results of survey on ~2000 adults) was lost to phone scams in America over the past 12 months. Americans received an average of 31 spam calls in a month, which was higher than the year before. Common reasons of these calls? Vehicle warranties, medicare, money owed for tax and bundle offers.
|
|
2. Blogposts: Fraud Detection 101 and Beyond
In case you missed, my blogpost series on 'Fraud Detection 101 and Beyond', following are 2-line summaries of the three articles I have written in the past. Each article delves into essential aspects of fraud detection and risk management.
1. Types of Fraud and Abuse - In this article, I explore various forms of fraud and abuse prevalent in today's digital landscape. By understanding the different types of fraud, such as credit card fraud, identity theft, fake news, account takeover etc., we can better design and implement effective detection and prevention strategies.
2. Traditional Detection Framework - This piece focuses on traditional fraud detection frameworks, which have been the backbone of many anti-fraud efforts. I discuss the strengths and weaknesses of rule-based systems, statistical models, and other conventional approaches, highlighting the importance of continuous adaptation to keep up with evolving threats.
3. Fraud Detection Frameworks - In this article, I provide general frameworks to approach the new problem in fraud detection depending on the data and/or label availability. I cover various techniques, including supervised and unsupervised learning, reputation scores, consortium and more, emphasizing their potential in the field of fraud prevention and risk management.
|
|
3. Spotlight Research
Cost Sensitive GNN-based Imbalanced Learning for Mobile Social Network Fraud Detection - Xinxin Hu et al. @ IEEE Transactions on Computational Social Systems, 2022
Published in IEEE Transactions on Computational Social Systems on Dec 2022, this paper by Xinxin Hu et al., proposes a cost sensitive graph neural network (GNN) based imbalanced learning method for fraud detection in mobile social networks. Let's dive in:
What is mobile social network fraud detection?
Mobile social network fraud detection involves identifying misuse of mobile services, such as spam calls or texts, to extract money. In 2022, this type of fraud resulted in an estimated loss of 39.5 billion USD.
What is imbalance problem?
In fraud scenarios, fraudulent users make up a small fraction of all users, resulting in imbalanced data. In the context of graphs, fraudulent nodes tend to have a large number of legitimate nodes in their vicinity, negatively affecting model predictions.
Why traditional imbalance data handling would not work?
Traditional methods, such as oversampling fraud events or undersampling legitimate ones, have drawbacks. Oversampling may lead to overfitting, while undersampling could result in information loss. Class weighting, a third method, gives different weights to fraudulent and legitimate events. This paper combines sampling and class weighting to handle imbalance.
How authors addressed it?
To improve node classification in imbalanced graphs, the authors proposed two strategies:
RL-based neighbor sampling: Reinforcement Learning (RL) is used to balance the fraudulent and legitimate population by determining how many similar neighbors should be sampled for each node. (middle plot in the figure above)
Cost-sensitive learning: After slightly balancing sub-graphs via neighbor sampling, a cost-sensitive loss function is used. This function imposes a higher penalty for misclassifying fraud than for misclassifying legitimate nodes. This is achieved by transforming the output GNN embeddings using a learnable cost-sensitive matrix, which emphasizes the different penalties for different types of misclassification. (right plot in the figure above)
What experiments were performed to prove that approach works?
The authors conducted experiments on two real-world, imbalanced telecom fraud datasets, having imbalance ratio of 0.47 and 0.08. They compared multiple GNN classification methods, including general GNNs, those optimized for fraud detection, and ones tuned for imbalanced data, against their proposed approach. The results demonstrated that their method outperformed all other compared approaches on both datasets.
|
|
Next month, 'AI for Trust, Safety and Fraud' will bring you more thought-provoking articles, industry news, and practical resources. Stay tuned!
The newsletter includes author's interpretation of news and research works, and can have errors. Please feel free to share feedbacks, errors or questions, if any.
|
|
|
|
|


[§431:21-118] Status of association policies. All financial institutions shall consider a policy issued by the association to be the same as a similar policy issued by an insurer authorized to transact insurance in this State. [L 1991, c 284, pt of §2]


In this example, build a support vector regression prediction model that uses the following features and labels:
| Data Category | Description |
|---|---|
| Features | Daily percent change of the open, high, low, close, and volume of the SPY over the last 5 days |
| Labels | Daily percent return of the SPY over the next day |
The following image shows the time difference between the features and labels:
To build the model, call the GridSearchCV
constructor with the SVR model, the parameter grid, a scoring method, the number of cross-validation folds:
param_grid = {'C': [.05, .1, .5, 1, 5, 10], 'epsilon': [0.001, 0.005, 0.01, 0.05, 0.1], 'gamma': ['auto', 'scale']} self.model = GridSearchCV(SVR(), param_grid, scoring='neg_mean_squared_error', cv=5)