All Classes
Booking
BookingController
CSV
Customer
CustomerController
Employee
EmployeeController
Film
FilmController
Firebase
LoginController
Main
MainController
NavbarController
Screening
SuperModel
User
UserController


Quote: Posted 12/15/09 20:56 (GMT) -- raven blackwood 92
the mage then is 20 +1d20 roll so a 8 or 9 is a tie to the monk or the caster?
Quote: Posted 12/15/09 20:56 (GMT) -- raven blackwood 92
anything else that affects this say spell craft save verse spells? Your wisdom? sorry trying to undersatnd the concept behind this.
Quote: Posted 06/28/06 00:22:49 (GMT) -- TyrTemplar
This post is for general information purposes only, and does not constitute a legal opinion or render any legal advice. It may not be relied on for any purpose, and gives rise to


About
Showreel & Portfolio
Contact Us
Our Awards
C
O
N
T
A
C
T
T
H
E
B
O
Y
S
Email us here!
We're also on AOL instant messenger!!!
Hit Us Up, Yo!
We are very interested to work with other production groups, discuss your project and collaborate. The best way to get in touch with us is by what we call "Beta Mail", otherwise knows as email:
Email Us:
<EMAIL_ADDRESS>Other Ways To Get in Touch:
YouTube:
Beta Boys Productions
Instagram:
Coming Soon
Keep it Beta
- Higgz & Horatio
© 2020 Beta Boys Productions


Hiding In Plain Sight
Fun With Steganography
What Is This Talk
A mostly silly guide to hiding information
Who Am I?
Chris Karper
Platform Architect @ Under Armour
Github: @ckarper
Twitter: @wickity
Steganography
Steganos (στεγανός) - Concealed, Protected
Graphein (γράφειν)- Writing
Steganography !== Cryptography
Cryptography
Encoding information, requiring a key to recover
Steganography
Concealed information, hidden within unrelated information
Steganography
+
Cryptography
Hidden, secured information
Writing notes with lemon juice or disappearing ink
Red glasses hidden messages
Hidden Rick Rolls in academic work
What does that have to do with us?
Hide Data In Images
Place small amounts of data inside image and video files
Least Significant Bits
Human perception is coarse,
let's take advantage!
BUT...
there's a limited capacity.
Source Image
Embed text
"I should buy a boat"
Code Sample
import fs from 'fs';
import f5 from 'f5stegojs';
// Initialize F5 Stego
const shuffleKey = [0x8, 0x6, 0x7, 0x5, 0x3, 0x0, 0x9, 0xe, 0x9];
const stegger = new f5(shuffleKey);
// Load working buffers
const outer = fs.readFileSync('relaxed-cat.jpg');
const inner = Buffer.from('I should buy a boat', 'utf8');
// Perform steganographic embed
const embedded = stegger.embed(outer, inner);
// Write output
fs.writeFileSync('embedded.jpg');
Resultant Image
Comparison
Now What?
Go play!
With This Great Power...
Comes No Responsibility


Night climbs will return to St Walburge’s Catholic Church spire in Preston next year
by Iain LynnPeople with a head for heights can climb to the top of St Walburge’s Catholic Church spire at night in the new year.
The Victorian Roman Catholic church will be open to climb each Saturday from January 11 until February 8, 2020.
Visitors can ascend the 309-foot (94 metre) high spire, which is the third tallest spire in the UK, and the tallest on a parish church.
READ MORE: The CoOp backing trio of good causes in Bamber Bridge and Lostock Hall
On a clear night visitors will have a excellent view of Preston, and the surrounding countryside as far as Blackpool.
The tower contains a single bell of 31 cwt (1.5 tonnes) cast by Mears and Stainbank of Whitechapel which is the heaviest swinging bell in Lancashire.
The times of access are 7.30 pm to 8.30 pm and ticket price is £8.50.
Tickets can be booked by email at<EMAIL_ADDRESS>and all proceeds will go to assist in the maintenance of this structure.


To download uthash, follow this link back to the GitHub project page.
A hash in C
This document is written for C programmers. Since you’re reading this, chances are that you know a hash is used for looking up items using a key. In scripting languages, hashes or "dictionaries" are used all the time. In C, hashes don’t exist in the language itself. This software provides a hash table for C structures.
What can it do?
This software supports these operations on items in a hash table:
-
add/replace
-
find
-
delete
-
count
-
iterate
-
sort
-
select
Is it fast?
Add, find and delete are normally constant-time operations. This is influenced by your key domain and the hash function.
This hash aims to be minimalistic and efficient. It’s around 900 lines of C. It inlines automatically because it’s implemented as macros. It’s fast as long as the hash function is suited to your keys. You can use the default hash function, or easily compare performance and choose from among several other built-in hash functions.
Is it a library?
No, it’s just a single header file: uthash.h
. All you need to do is copy
the header file into your project, and:
#include "uthash.h"
Since uthash is a header file only, there is no library code to link against.
C/C++ and platforms
This software can be used in C and C++ programs. It has been tested on:
-
Linux
-
Mac OS X
-
Windows using Visual Studio 2008 and 2010
-
Solaris
-
OpenBSD
-
FreeBSD
Windows users: as of 2013 it’s been a while since I had the environment to test uthash under Visual Studio. If someone wants to run the unit tests under the latest Visual Studio and confirm that its still clean, that’d be appreciated.
Test suite
To run the test suite, enter the tests
directory. Then,
-
on Unix platforms, run
make
-
on Windows, run the "do_tests_win32.cmd" batch file. (You may edit the batch file if your Visual Studio is installed in a non-standard location).
BSD licensed
This software is made available under the revised BSD license. It is free and open source.
Download uthash
Follow the links on https://github.com/troydhanson/uthash to clone uthash or get a zip file.
Getting help
I encourage people to use the public Google Group to ask questions<EMAIL_ADDRESS>You can browse it at: https://groups.google.com/d/forum/uthash
If you are experienced with uthash and like to answer questions, please join the group and chime in when someone asks a question. That would be a great help!
Contacting the author
You can email me at<EMAIL_ADDRESS>or message @troydhanson on Twitter. I can’t always answer my email, and when I do, it’s sometimes weeks later. Sorry!
Contributing
If you add a new feature or fix something in uthash or in the extras, please make a pull request on Github. For anything other than a trivial change, include a unit test and documentation if you possibly can. (And don’t be discouraged if it takes weeks or even months for me to merge it. Sorry, my life is busy!) Thanks!
Extras included
Three "extras" come with uthash. These provide lists, dynamic arrays and strings:
-
utlist.h provides linked list macros for C structures.
-
utarray.h implements dynamic arrays using macros.
-
utstring.h implements a basic dynamic string.
There’s also a small LRU cache API, based on uthash, in tests/lru_cache
.
Other software
Other open-source software by the author is listed at http://tkhanson.net.
News
The author has a blog for software updates . You can also follow @troydhanson on Twitter for updates.
Who’s using it?
Uthash was downloaded around 30,000 times between 2006-2013 then transitioned to GitHub. It’s been incorporated into commercial software, academic research, and into other open-source software. It has also been added to the native package repositories for a number of Unix-y distros.
When uthash was written, there were fewer options for doing generic hash tables in C than exist today. There are faster hash tables, more memory-efficient hash tables, with very different API’s today. But, like driving a minivan, uthash is convenient, and gets the job done without drawing a lot of attention to itself.
Your structure
In uthash, a hash table is comprised of structures. Each structure represents a key-value association. One or more of the structure fields constitute the key. The structure pointer itself is the value.
#include "uthash.h"
struct my_struct {
int id; /* key */
char name[10];
UT_hash_handle hh; /* makes this structure hashable */
};
Note that, in uthash, your structure will never be moved or copied into another location when you add it into a hash table. This means that you can keep other data structures that safely point to your structure-- regardless of whether you add or delete it from a hash table during your program’s lifetime.
The key
There are no restrictions on the data type or name of the key field. The key can also comprise multiple contiguous fields, having any names and data types.
Unique keys
As with any hash, every item must have a unique key. Your application must
enforce key uniqueness. Before you add an item to the hash table, you must
first know (if in doubt, check!) that the key is not already in use. You
can check whether a key already exists in the hash table using HASH_FIND
.
The hash handle
The UT_hash_handle
field must be present in your structure. It is used for
the internal bookkeeping that makes the hash work. It does not require
initialization. It can be named anything, but you can simplify matters by
naming it hh
. This allows you to use the easier "convenience" macros to add,
find and delete items.
A word about memory
Overhead
The hash handle consumes about 32 bytes per item on a 32-bit system, or 56 bytes
per item on a 64-bit system. The other overhead costs-- the buckets and the
table-- are negligible in comparison. You can use HASH_OVERHEAD
to get the
overhead size, in bytes, for a hash table. See Macro Reference.
How clean up occurs
Some have asked how uthash cleans up its internal memory. The answer is simple: when you delete the final item from a hash table, uthash releases all the internal memory associated with that hash table, and sets its pointer to NULL.
Hash operations
This section introduces the uthash macros by example. For a more succinct listing, see Macro Reference.
Declare the hash
Your hash must be declared as a NULL
-initialized pointer to your structure.
struct my_struct *users = NULL; /* important! initialize to NULL */
Add item
Allocate and initialize your structure as you see fit. The only aspect
of this that matters to uthash is that your key must be initialized to
a unique value. Then call HASH_ADD
. (Here we use the convenience macro
HASH_ADD_INT
, which offers simplified usage for keys of type int
).
void add_user(int user_id, char *name) {
struct my_struct *s;
s = malloc(sizeof(struct my_struct));
s->id = user_id;
strcpy(s->name, name);
HASH_ADD_INT( users, id, s ); /* id: name of key field */
}
The first parameter to HASH_ADD_INT
is the hash table, and the
second parameter is the name of the key field. Here, this is id
. The
last parameter is a pointer to the structure being added.
Key must not be modified while in-use
Once a structure has been added to the hash, do not change the value of its key. Instead, delete the item from the hash, change the key, and then re-add it.
Checking uniquness
In the example above, we didn’t check to see if user_id
was already a key
of some existing item in the hash. If there’s any chance that duplicate keys
could be generated by your program, you must explicitly check the uniqueness
before adding the key to the hash. If the key is already in the hash, you can
simply modify the existing structure in the hash rather than adding the item.
It is an error to add two items with the same key to the hash table.
Let’s rewrite the add_user
function to check whether the id is in the hash.
Only if the id is not present in the hash, do we create the item and add it.
Otherwise we just modify the structure that already exists.
void add_user(int user_id, char *name) {
struct my_struct *s;
HASH_FIND_INT(users, &user_id, s); /* id already in the hash? */
if (s==NULL) {
s = (struct my_struct*)malloc(sizeof(struct my_struct));
s->id = user_id;
HASH_ADD_INT( users, id, s ); /* id: name of key field */
}
strcpy(s->name, name);
}
Why doesn’t uthash check key uniqueness for you? It saves the cost of a hash lookup for those programs which don’t need it- for example, programs whose keys are generated by an incrementing, non-repeating counter.
However, if replacement is a common operation, it is possible to use the
HASH_REPLACE
macro. This macro, before adding the item, will try to find an
item with the same key and delete it first. It also returns a pointer to the
replaced item, so the user has a chance to de-allocate its memory.
Passing the hash pointer into functions
In the example above users
is a global variable, but what if the caller wanted
to pass the hash pointer into the add_user
function? At first glance it would
appear that you could simply pass users
as an argument, but that won’t work
right.
/* bad */
void add_user(struct my_struct *users, int user_id, char *name) {
...
HASH_ADD_INT( users, id, s );
}
You really need to pass a pointer to the hash pointer:
/* good */
void add_user(struct my_struct **users, int user_id, char *name) { ...
...
HASH_ADD_INT( *users, id, s );
}
Note that we dereferenced the pointer in the HASH_ADD
also.
The reason it’s necessary to deal with a pointer to the hash pointer is simple: the hash macros modify it (in other words, they modify the pointer itself not just what it points to).
Replace item
HASH_REPLACE
macros are equivalent to HASH_ADD macros except they attempt
to find and delete the item first. If it find and deletes and item, it will
also return that items pointer as an output parameter.
Find item
To look up a structure in a hash, you need its key. Then call HASH_FIND
.
(Here we use the convenience macro HASH_FIND_INT
for keys of type int
).
struct my_struct *find_user(int user_id) {
struct my_struct *s;
HASH_FIND_INT( users, &user_id, s ); /* s: output pointer */
return s;
}
Here, the hash table is users
, and &user_id
points to the key (an integer
in this case). Last, s
is the output variable of HASH_FIND_INT
. The
final result is that s
points to the structure with the given key, or
is NULL
if the key wasn’t found in the hash.
|
Note
|
The middle argument is a pointer to the key. You can’t pass a literal key
value to HASH_FIND . Instead assign the literal value to a variable, and pass
a pointer to the variable. |
Delete item
To delete a structure from a hash, you must have a pointer to it. (If you only
have the key, first do a HASH_FIND
to get the structure pointer).
void delete_user(struct my_struct *user) {
HASH_DEL( users, user); /* user: pointer to deletee */
free(user); /* optional; it's up to you! */
}
Here again, users
is the hash table, and user
is a pointer to the
structure we want to remove from the hash.
uthash never frees your structure
Deleting a structure just removes it from the hash table-- it doesn’t free
it. The choice of when to free your structure is entirely up to you; uthash
will never free your structure. For example when using HASH_REPLACE
macros,
a replaced output argument is returned back, in order to make it possible for
the user to de-allocate it.
Delete can change the pointer
The hash table pointer (which initially points to the first item added to the
hash) can change in response to HASH_DEL
(i.e. if you delete the first item
in the hash table).
Iterative deletion
The HASH_ITER
macro is a deletion-safe iteration construct which expands
to a simple for loop.
void delete_all() {
struct my_struct *current_user, *tmp;
HASH_ITER(hh, users, current_user, tmp) {
HASH_DEL(users,current_user); /* delete; users advances to next */
free(current_user); /* optional- if you want to free */
}
}
All-at-once deletion
If you only want to delete all the items, but not free them or do any per-element clean up, you can do this more efficiently in a single operation:
HASH_CLEAR(hh,users);
Afterward, the list head (here, users
) will be set to NULL
.
Count items
The number of items in the hash table can be obtained using HASH_COUNT
:
unsigned int num_users;
num_users = HASH_COUNT(users);
printf("there are %u users\n", num_users);
Incidentally, this works even the list (users
, here) is NULL
, in
which case the count is 0.
Iterating and sorting
You can loop over the items in the hash by starting from the beginning and
following the hh.next
pointer.
void print_users() {
struct my_struct *s;
for(s=users; s != NULL; s=s->hh.next) {
printf("user id %d: name %s\n", s->id, s->name);
}
}
There is also an hh.prev
pointer you could use to iterate backwards through
the hash, starting from any known item.
Deletion-safe iteration
In the example above, it would not be safe to delete and free s
in the body
of the for loop, (because s
is derefenced each time the loop iterates).
This is easy to rewrite correctly (by copying the s->hh.next
pointer to a
temporary variable before freeing s
), but it comes up often enough that a
deletion-safe iteration macro, HASH_ITER
, is included. It expands to a
for
-loop header. Here is how it could be used to rewrite the last example:
struct my_struct *s, *tmp;
HASH_ITER(hh, users, s, tmp) {
printf("user id %d: name %s\n", s->id, s->name);
/* ... it is safe to delete and free s here */
}
If you’re using uthash in a C++ program, you need an extra cast on the for
iterator, e.g., s=(struct my_struct*)s->hh.next
.
Sorting
The items in the hash are visited in "insertion order" when you follow the
hh.next
pointer. You can sort the items into a new order using HASH_SORT
.
HASH_SORT( users, name_sort );
The second argument is a pointer to a comparison function. It must accept two
pointer arguments (the items to compare), and must return an int
which is
less than zero, zero, or greater than zero, if the first item sorts before,
equal to, or after the second item, respectively. (This is the same convention
used by strcmp
or qsort
in the standard C library).
int sort_function(void *a, void *b) {
/* compare a to b (cast a and b appropriately)
* return (int) -1 if (a < b)
* return (int) 0 if (a == b)
* return (int) 1 if (a > b)
*/
}
Below, name_sort
and id_sort
are two examples of sort functions.
int name_sort(struct my_struct *a, struct my_struct *b) {
return strcmp(a->name,b->name);
}
int id_sort(struct my_struct *a, struct my_struct *b) {
return (a->id - b->id);
}
void sort_by_name() {
HASH_SORT(users, name_sort);
}
void sort_by_id() {
HASH_SORT(users, id_sort);
}
When the items in the hash are sorted, the first item may change position. In
the example above, users
may point to a different structure after calling
HASH_SORT
.
A complete example
We’ll repeat all the code and embellish it with a main()
function to form a
working example.
If this code was placed in a file called example.c
in the same directory as
uthash.h
, it could be compiled and run like this:
cc -o example example.c
./example
Follow the prompts to try the program.
#include <stdio.h> /* gets */
#include <stdlib.h> /* atoi, malloc */
#include <string.h> /* strcpy */
#include "uthash.h"
struct my_struct {
int id; /* key */
char name[10];
UT_hash_handle hh; /* makes this structure hashable */
};
struct my_struct *users = NULL;
void add_user(int user_id, char *name) {
struct my_struct *s;
HASH_FIND_INT(users, &user_id, s); /* id already in the hash? */
if (s==NULL) {
s = (struct my_struct*)malloc(sizeof(struct my_struct));
s->id = user_id;
HASH_ADD_INT( users, id, s ); /* id: name of key field */
}
strcpy(s->name, name);
}
struct my_struct *find_user(int user_id) {
struct my_struct *s;
HASH_FIND_INT( users, &user_id, s ); /* s: output pointer */
return s;
}
void delete_user(struct my_struct *user) {
HASH_DEL( users, user); /* user: pointer to deletee */
free(user);
}
void delete_all() {
struct my_struct *current_user, *tmp;
HASH_ITER(hh, users, current_user, tmp) {
HASH_DEL(users,current_user); /* delete it (users advances to next) */
free(current_user); /* free it */
}
}
void print_users() {
struct my_struct *s;
for(s=users; s != NULL; s=(struct my_struct*)(s->hh.next)) {
printf("user id %d: name %s\n", s->id, s->name);
}
}
int name_sort(struct my_struct *a, struct my_struct *b) {
return strcmp(a->name,b->name);
}
int id_sort(struct my_struct *a, struct my_struct *b) {
return (a->id - b->id);
}
void sort_by_name() {
HASH_SORT(users, name_sort);
}
void sort_by_id() {
HASH_SORT(users, id_sort);
}
int main(int argc, char *argv[]) {
char in[10];
int id=1, running=1;
struct my_struct *s;
unsigned num_users;
while (running) {
printf(" 1. add user\n");
printf(" 2. add/rename user by id\n");
printf(" 3. find user\n");
printf(" 4. delete user\n");
printf(" 5. delete all users\n");
printf(" 6. sort items by name\n");
printf(" 7. sort items by id\n");
printf(" 8. print users\n");
printf(" 9. count users\n");
printf("10. quit\n");
gets(in);
switch(atoi(in)) {
case 1:
printf("name?\n");
add_user(id++, gets(in));
break;
case 2:
printf("id?\n");
gets(in); id = atoi(in);
printf("name?\n");
add_user(id, gets(in));
break;
case 3:
printf("id?\n");
s = find_user(atoi(gets(in)));
printf("user: %s\n", s ? s->name : "unknown");
break;
case 4:
printf("id?\n");
s = find_user(atoi(gets(in)));
if (s) delete_user(s);
else printf("id unknown\n");
break;
case 5:
delete_all();
break;
case 6:
sort_by_name();
break;
case 7:
sort_by_id();
break;
case 8:
print_users();
break;
case 9:
num_users=HASH_COUNT(users);
printf("there are %u users\n", num_users);
break;
case 10:
running=0;
break;
}
}
delete_all(); /* free any structures */
return 0;
}
This program is included in the distribution in tests/example.c
. You can run
make example
in that directory to compile it easily.
Standard key types
This section goes into specifics of how to work with different kinds of keys. You can use nearly any type of key-- integers, strings, pointers, structures, etc.
|
Note
|
A note about float
You can use floating point keys. This comes with the same caveats as with any program that tests floating point equality. In other words, even the tiniest difference in two floating point numbers makes them distinct keys. |
Integer keys
The preceding examples demonstrated use of integer keys. To recap, use the
convenience macros HASH_ADD_INT
and HASH_FIND_INT
for structures with
integer keys. (The other operations such as HASH_DELETE
and HASH_SORT
are
the same for all types of keys).
String keys
If your structure has a string key, the operations to use depend on whether your
structure points to the key (char *
) or the string resides within
the
structure (char a[10]
). This distinction is important. As we’ll see below,
you need to use HASH_ADD_KEYPTR
when your structure points to a key (that is,
the key itself is outside of the structure); in contrast, use HASH_ADD_STR
for a string key that is contained within your structure.
|
Note
|
char[ ] vs. char*
The string is within the structure in the first example below-- |
String within structure
#include <string.h> /* strcpy */
#include <stdlib.h> /* malloc */
#include <stdio.h> /* printf */
#include "uthash.h"
struct my_struct {
char name[10]; /* key (string is WITHIN the structure) */
int id;
UT_hash_handle hh; /* makes this structure hashable */
};
int main(int argc, char *argv[]) {
const char **n, *names[] = { "joe", "bob", "betty", NULL };
struct my_struct *s, *tmp, *users = NULL;
int i=0;
for (n = names; *n != NULL; n++) {
s = (struct my_struct*)malloc(sizeof(struct my_struct));
strncpy(s->name, *n,10);
s->id = i++;
HASH_ADD_STR( users, name, s );
}
HASH_FIND_STR( users, "betty", s);
if (s) printf("betty's id is %d\n", s->id);
/* free the hash table contents */
HASH_ITER(hh, users, s, tmp) {
HASH_DEL(users, s);
free(s);
}
return 0;
}
This example is included in the distribution in tests/test15.c
. It prints:
betty's id is 2
String pointer in structure
Now, here is the same example but using a char *
key instead of char [ ]
:
#include <string.h> /* strcpy */
#include <stdlib.h> /* malloc */
#include <stdio.h> /* printf */
#include "uthash.h"
struct my_struct {
const char *name; /* key */
int id;
UT_hash_handle hh; /* makes this structure hashable */
};
int main(int argc, char *argv[]) {
const char **n, *names[] = { "joe", "bob", "betty", NULL };
struct my_struct *s, *tmp, *users = NULL;
int i=0;
for (n = names; *n != NULL; n++) {
s = (struct my_struct*)malloc(sizeof(struct my_struct));
s->name = *n;
s->id = i++;
HASH_ADD_KEYPTR( hh, users, s->name, strlen(s->name), s );
}
HASH_FIND_STR( users, "betty", s);
if (s) printf("betty's id is %d\n", s->id);
/* free the hash table contents */
HASH_ITER(hh, users, s, tmp) {
HASH_DEL(users, s);
free(s);
}
return 0;
}
This example is included in tests/test40.c
.
Pointer keys
Your key can be a pointer. To be very clear, this means the pointer itself
can be the key (in contrast, if the thing pointed to is the key, this is a
different use case handled by HASH_ADD_KEYPTR
).
Here is a simple example where a structure has a pointer member, called key
.
#include <stdio.h>
#include <stdlib.h>
#include "uthash.h"
typedef struct {
void *key;
int i;
UT_hash_handle hh;
} el_t;
el_t *hash = NULL;
char *someaddr = NULL;
int main() {
el_t *d;
el_t *e = (el_t*)malloc(sizeof(el_t));
if (!e) return -1;
e->key = (void*)someaddr;
e->i = 1;
HASH_ADD_PTR(hash,key,e);
HASH_FIND_PTR(hash, &someaddr, d);
if (d) printf("found\n");
/* release memory */
HASH_DEL(hash,e);
free(e);
return 0;
}
This example is included in tests/test57.c
. Note that the end of the program
deletes the element out of the hash, (and since no more elements remain in the
hash), uthash releases its internal memory.
Structure keys
Your key field can have any data type. To uthash, it is just a sequence of
bytes. Therefore, even a nested structure can be used as a key. We’ll use the
general macros HASH_ADD
and HASH_FIND
to demonstrate.
|
Note
|
Structures contain padding (wasted internal space used to fulfill
alignment requirements for the members of the structure). These padding bytes
must be zeroed before adding an item to the hash or looking up an item.
Therefore always zero the whole structure before setting the members of
interest. The example below does this-- see the two calls to memset . |
#include <stdlib.h>
#include <stdio.h>
#include "uthash.h"
typedef struct {
char a;
int b;
} record_key_t;
typedef struct {
record_key_t key;
/* ... other data ... */
UT_hash_handle hh;
} record_t;
int main(int argc, char *argv[]) {
record_t l, *p, *r, *tmp, *records = NULL;
r = (record_t*)malloc( sizeof(record_t) );
memset(r, 0, sizeof(record_t));
r->key.a = 'a';
r->key.b = 1;
HASH_ADD(hh, records, key, sizeof(record_key_t), r);
memset(&l, 0, sizeof(record_t));
l.key.a = 'a';
l.key.b = 1;
HASH_FIND(hh, records, &l.key, sizeof(record_key_t), p);
if (p) printf("found %c %d\n", p->key.a, p->key.b);
HASH_ITER(hh, records, p, tmp) {
HASH_DEL(records, p);
free(p);
}
return 0;
}
This usage is nearly the same as use of a compound key explained below.
Note that the general macros require the name of the UT_hash_handle
to be
passed as the first argument (here, this is hh
). The general macros are
documented in Macro Reference.
Advanced Topics
Compound keys
Your key can even comprise multiple contiguous fields.
#include <stdlib.h> /* malloc */
#include <stddef.h> /* offsetof */
#include <stdio.h> /* printf */
#include <string.h> /* memset */
#include "uthash.h"
#define UTF32 1
typedef struct {
UT_hash_handle hh;
int len;
char encoding; /* these two fields */
int text[]; /* comprise the key */
} msg_t;
typedef struct {
char encoding;
int text[];
} lookup_key_t;
int main(int argc, char *argv[]) {
unsigned keylen;
msg_t *msg, *tmp, *msgs = NULL;
lookup_key_t *lookup_key;
int beijing[] = {0x5317, 0x4eac}; /* UTF-32LE for 北京 */
/* allocate and initialize our structure */
msg = (msg_t*)malloc( sizeof(msg_t) + sizeof(beijing) );
memset(msg, 0, sizeof(msg_t)+sizeof(beijing)); /* zero fill */
msg->len = sizeof(beijing);
msg->encoding = UTF32;
memcpy(msg->text, beijing, sizeof(beijing));
/* calculate the key length including padding, using formula */
keylen = offsetof(msg_t, text) /* offset of last key field */
+ sizeof(beijing) /* size of last key field */
- offsetof(msg_t, encoding); /* offset of first key field */
/* add our structure to the hash table */
HASH_ADD( hh, msgs, encoding, keylen, msg);
/* look it up to prove that it worked :-) */
msg=NULL;
lookup_key = (lookup_key_t*)malloc(sizeof(*lookup_key) + sizeof(beijing));
memset(lookup_key, 0, sizeof(*lookup_key) + sizeof(beijing));
lookup_key->encoding = UTF32;
memcpy(lookup_key->text, beijing, sizeof(beijing));
HASH_FIND( hh, msgs, &lookup_key->encoding, keylen, msg );
if (msg) printf("found \n");
free(lookup_key);
HASH_ITER(hh, msgs, msg, tmp) {
HASH_DEL(msgs, msg);
free(msg);
}
return 0;
}
This example is included in the distribution in tests/test22.c
.
If you use multi-field keys, recognize that the compiler pads adjacent fields
(by inserting unused space between them) in order to fulfill the alignment
requirement of each field. For example a structure containing a char
followed
by an int
will normally have 3 "wasted" bytes of padding after the char, in
order to make the int
field start on a multiple-of-4 address (4 is the length
of the int).
When dealing with a multi-field key, you must zero-fill your structure before
HASH_ADD
'ing it to a hash table, or using its fields in a HASH_FIND
key.
In the previous example, memset
is used to initialize the structure by
zero-filling it. This zeroes out any padding between the key fields. If we
didn’t zero-fill the structure, this padding would contain random values. The
random values would lead to HASH_FIND
failures; as two "identical" keys will
appear to mismatch if there are any differences within their padding.
Multi-level hash tables
A multi-level hash table arises when each element of a hash table contains its own secondary hash table. There can be any number of levels. In a scripting language you might see:
$items{bob}{age}=37
The C program below builds this example in uthash: the hash table is called
items
. It contains one element (bob
) whose own hash table contains one
element (age
) with value 37. No special functions are necessary to build
a multi-level hash table.
While this example represents both levels (bob
and age
) using the same
structure, it would also be fine to use two different structure definitions.
It would also be fine if there were three or more levels instead of two.
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "uthash.h"
/* hash of hashes */
typedef struct item {
char name[10];
struct item *sub;
int val;
UT_hash_handle hh;
} item_t;
item_t *items=NULL;
int main(int argc, char *argvp[]) {
item_t *item1, *item2, *tmp1, *tmp2;
/* make initial element */
item_t *i = malloc(sizeof(*i));
strcpy(i->name, "bob");
i->sub = NULL;
i->val = 0;
HASH_ADD_STR(items, name, i);
/* add a sub hash table off this element */
item_t *s = malloc(sizeof(*s));
strcpy(s->name, "age");
s->sub = NULL;
s->val = 37;
HASH_ADD_STR(i->sub, name, s);
/* iterate over hash elements */
HASH_ITER(hh, items, item1, tmp1) {
HASH_ITER(hh, item1->sub, item2, tmp2) {
printf("$items{%s}{%s} = %d\n", item1->name, item2->name, item2->val);
}
}
/* clean up both hash tables */
HASH_ITER(hh, items, item1, tmp1) {
HASH_ITER(hh, item1->sub, item2, tmp2) {
HASH_DEL(item1->sub, item2);
free(item2);
}
HASH_DEL(items, item1);
free(item1);
}
return 0;
}
The example above is included in tests/test59.c
.
Items in several hash tables
A structure can be added to more than one hash table. A few reasons you might do this include:
-
each hash table may use an alternative key;
-
each hash table may have its own sort order;
-
or you might simply use multiple hash tables for grouping purposes. E.g., you could have users in an
admin_users
and ausers
hash table.
Your structure needs to have a UT_hash_handle
field for each hash table to
which it might be added. You can name them anything. E.g.,
UT_hash_handle hh1, hh2;
Items with alternative keys
You might create a hash table keyed on an ID field, and another hash table keyed
on username (if usernames are unique). You can add the same user structure to
both hash tables (without duplication of the structure), allowing lookup of a
user structure by their name or ID. The way to achieve this is to have a
separate UT_hash_handle
for each hash to which the structure may be added.
struct my_struct {
int id; /* usual key */
char username[10]; /* alternative key */
UT_hash_handle hh1; /* handle for first hash table */
UT_hash_handle hh2; /* handle for second hash table */
};
In the example above, the structure can now be added to two separate hash
tables. In one hash, id
is its key, while in the other hash, username
is
its key. (There is no requirement that the two hashes have different key
fields. They could both use the same key, such as id
).
Notice the structure has two hash handles (hh1
and hh2
). In the code
below, notice that each hash handle is used exclusively with a particular hash
table. (hh1
is always used with the users_by_id
hash, while hh2
is
always used with the users_by_name
hash table).
struct my_struct *users_by_id = NULL, *users_by_name = NULL, *s;
int i;
char *name;
s = malloc(sizeof(struct my_struct));
s->id = 1;
strcpy(s->username, "thanson");
/* add the structure to both hash tables */
HASH_ADD(hh1, users_by_id, id, sizeof(int), s);
HASH_ADD(hh2, users_by_name, username, strlen(s->username), s);
/* lookup user by ID in the "users_by_id" hash table */
i=1;
HASH_FIND(hh1, users_by_id, &i, sizeof(int), s);
if (s) printf("found id %d: %s\n", i, s->username);
/* lookup user by username in the "users_by_name" hash table */
name = "thanson";
HASH_FIND(hh2, users_by_name, name, strlen(name), s);
if (s) printf("found user %s: %d\n", name, s->id);
Several sort orders
It comes as no suprise that two hash tables can have different sort orders, but this fact can also be used advantageously to sort the same items in several ways. This is based on the ability to store a structure in several hash tables.
Extending the previous example, suppose we have many users. We have added each
user structure to the users_by_id
hash table and the users_by_name
hash table.
(To reiterate, this is done without the need to have two copies of each structure).
Now we can define two sort functions, then use HASH_SRT
.
int sort_by_id(struct my_struct *a, struct my_struct *b) {
if (a->id == b->id) return 0;
return (a->id < b->id) ? -1 : 1;
}
int sort_by_name(struct my_struct *a, struct my_struct *b) {
return strcmp(a->username,b->username);
}
HASH_SRT(hh1, users_by_id, sort_by_id);
HASH_SRT(hh2, users_by_name, sort_by_name);
Now iterating over the items in users_by_id
will traverse them in id-order
while, naturally, iterating over users_by_name
will traverse them in
name-order. The items are fully forward-and-backward linked in each order.
So even for one set of users, we might store them in two hash tables to provide
easy iteration in two different sort orders.
Bloom filter (faster misses)
Programs that generate a fair miss rate (HASH_FIND
that result in NULL
) may
benefit from the built-in Bloom filter support. This is disabled by default,
because programs that generate only hits would incur a slight penalty from it.
Also, programs that do deletes should not use the Bloom filter. While the
program would operate correctly, deletes diminish the benefit of the filter.
To enable the Bloom filter, simply compile with -DHASH_BLOOM=n
like:
-DHASH_BLOOM=27
where the number can be any value up to 32 which determines the amount of memory used by the filter, as shown below. Using more memory makes the filter more accurate and has the potential to speed up your program by making misses bail out faster.
| n | Bloom filter size (per hash table) |
|---|---|
|
8 kilobytes |
|
128 kilobytes |
|
2 megabytes |
|
32 megabytes |
|
512 megabytes |
Bloom filters are only a performance feature; they do not change the results of hash operations in any way. The only way to gauge whether or not a Bloom filter is right for your program is to test it. Reasonable values for the size of the Bloom filter are 16-32 bits.
Select
An experimental select operation is provided that inserts those items from a
source hash that satisfy a given condition into a destination hash. This
insertion is done with somewhat more efficiency than if this were using
HASH_ADD
, namely because the hash function is not recalculated for keys of the
selected items. This operation does not remove any items from the source hash.
Rather the selected items obtain dual presence in both hashes. The destination
hash may already have items in it; the selected items are added to it. In order
for a structure to be usable with HASH_SELECT
, it must have two or more hash
handles. (As described here, a structure can exist in many
hash tables at the same time; it must have a separate hash handle for each one).
user_t *users=NULL, *admins=NULL; /* two hash tables */
typedef struct {
int id;
UT_hash_handle hh; /* handle for users hash */
UT_hash_handle ah; /* handle for admins hash */
} user_t;
Now suppose we have added some users, and want to select just the administrator users who have id’s less than 1024.
#define is_admin(x) (((user_t*)x)->id < 1024)
HASH_SELECT(ah,admins,hh,users,is_admin);
The first two parameters are the destination hash handle and hash table, the
second two parameters are the source hash handle and hash table, and the last
parameter is the select condition. Here we used a macro is_admin()
but we
could just as well have used a function.
int is_admin(void *userv) {
user_t *user = (user_t*)userv;
return (user->id < 1024) ? 1 : 0;
}
If the select condition always evaluates to true, this operation is
essentially a merge of the source hash into the destination hash. Of course,
the source hash remains unchanged under any use of HASH_SELECT
. It only adds
items to the destination hash selectively.
The two hash handles must differ. An example of using HASH_SELECT
is included
in tests/test36.c
.
Built-in hash functions
Internally, a hash function transforms a key into a bucket number. You don’t have to take any action to use the default hash function, currently Jenkin’s.
Some programs may benefit from using another of the built-in hash functions. There is a simple analysis utility included with uthash to help you determine if another hash function will give you better performance.
You can use a different hash function by compiling your program with
-DHASH_FUNCTION=HASH_xyz
where xyz
is one of the symbolic names listed
below. E.g.,
cc -DHASH_FUNCTION=HASH_BER -o program program.c
| Symbol | Name |
|---|---|
|
Jenkins (default) |
|
Bernstein |
|
Shift-Add-Xor |
|
One-at-a-time |
|
Fowler/Noll/Vo |
|
Paul Hsieh |
|
MurmurHash v3 (see note) |
|
Note
|
MurmurHash
A special symbol must be defined if you intend to use MurmurHash. To use it, add
|
Which hash function is best?
You can easily determine the best hash function for your key domain. To do so, you’ll need to run your program once in a data-collection pass, and then run the collected data through an included analysis utility.
First you must build the analysis utility. From the top-level directory,
cd tests/
make
We’ll use test14.c
to demonstrate the data-collection and analysis steps
(here using sh
syntax to redirect file descriptor 3 to a file):
% cc -DHASH_EMIT_KEYS=3 -I../src -o test14 test14.c
% ./test14 3>test14.keys
% ./keystats test14.keys
fcn ideal% #items #buckets dup% fl add_usec find_usec del-all usec
--- ------ ---------- ---------- ----- -- ---------- ---------- ------------
SFH 91.6% 1219 256 0% ok 92 131 25
FNV 90.3% 1219 512 0% ok 107 97 31
SAX 88.7% 1219 512 0% ok 111 109 32
OAT 87.2% 1219 256 0% ok 99 138 26
JEN 86.7% 1219 256 0% ok 87 130 27
BER 86.2% 1219 256 0% ok 121 129 27
|
Note
|
The number 3 in -DHASH_EMIT_KEYS=3 is a file descriptor. Any file descriptor
that your program doesn’t use for its own purposes can be used instead of 3.
The data-collection mode enabled by -DHASH_EMIT_KEYS=x should not be used in
production code. |
Usually, you should just pick the first hash function that is listed. Here, this
is SFH
. This is the function that provides the most even distribution for
your keys. If several have the same ideal%
, then choose the fastest one
according to the find_usec
column.
keystats column reference
- fcn
-
symbolic name of hash function
- ideal%
-
The percentage of items in the hash table which can be looked up within an ideal number of steps. (Further explained below).
- #items
-
the number of keys that were read in from the emitted key file
- #buckets
-
the number of buckets in the hash after all the keys were added
- dup%
-
the percent of duplicate keys encountered in the emitted key file. Duplicates keys are filtered out to maintain key uniqueness. (Duplicates are normal. For example, if the application adds an item to a hash, deletes it, then re-adds it, the key is written twice to the emitted file.)
- flags
-
this is either
ok
, ornx
(noexpand) if the expansion inhibited flag is set, described in Expansion internals. It is not recommended to use a hash function that has thenoexpand
flag set. - add_usec
-
the clock time in microseconds required to add all the keys to a hash
- find_usec
-
the clock time in microseconds required to look up every key in the hash
- del-all usec
-
the clock time in microseconds required to delete every item in the hash
ideal%
hashscan
|
Note
|
This utility is only available on Linux, and on FreeBSD (8.1 and up). |
A utility called hashscan
is included in the tests/
directory. It
is built automatically when you run make
in that directory. This tool
examines a running process and reports on the uthash tables that it finds in
that program’s memory. It can also save the keys from each table in a format
that can be fed into keystats
.
Here is an example of using hashscan
. First ensure that it is built:
cd tests/
make
Since hashscan
needs a running program to inspect, we’ll start up a simple
program that makes a hash table and then sleeps as our test subject:
./test_sleep &
pid: 9711
Now that we have a test program, let’s run hashscan
on it:
./hashscan 9711
Address ideal items buckets mc fl bloom/sat fcn keys saved to
------------------ ----- -------- -------- -- -- --------- --- -------------
0x862e038 81% 10000 4096 11 ok 16 14% JEN
If we wanted to copy out all its keys for external analysis using keystats
,
add the -k
flag:
./hashscan -k 9711
Address ideal items buckets mc fl bloom/sat fcn keys saved to
------------------ ----- -------- -------- -- -- --------- --- -------------
0x862e038 81% 10000 4096 11 ok 16 14% JEN /tmp/9711-0.key
Now we could run ./keystats /tmp/9711-0.key
to analyze which hash function
has the best characteristics on this set of keys.
hashscan column reference
- Address
-
virtual address of the hash table
- ideal
-
The percentage of items in the table which can be looked up within an ideal number of steps. See [ideal] in the
keystats
section. - items
-
number of items in the hash table
- buckets
-
number of buckets in the hash table
- mc
-
the maximum chain length found in the hash table (uthash usually tries to keep fewer than 10 items in each bucket, or in some cases a multiple of 10)
- fl
-
flags (either
ok
, orNX
if the expansion-inhibited flag is set) - bloom/sat
-
if the hash table uses a Bloom filter, this is the size (as a power of two) of the filter (e.g. 16 means the filter is 2^16 bits in size). The second number is the "saturation" of the bits expressed as a percentage. The lower the percentage, the more potential benefit to identify cache misses quickly.
- fcn
-
symbolic name of hash function
- keys saved to
-
file to which keys were saved, if any
Expansion internals
Internally this hash manages the number of buckets, with the goal of having enough buckets so that each one contains only a small number of items.
Normal expansion
This hash attempts to keep fewer than 10 items in each bucket. When an item is added that would cause a bucket to exceed this number, the number of buckets in the hash is doubled and the items are redistributed into the new buckets. In an ideal world, each bucket will then contain half as many items as it did before.
Bucket expansion occurs automatically and invisibly as needed. There is no need for the application to know when it occurs.
Per-bucket expansion threshold
Normally all buckets share the same threshold (10 items) at which point bucket expansion is triggered. During the process of bucket expansion, uthash can adjust this expansion-trigger threshold on a per-bucket basis if it sees that certain buckets are over-utilized.
When this threshold is adjusted, it goes from 10 to a multiple of 10 (for that particular bucket). The multiple is based on how many times greater the actual chain length is than the ideal length. It is a practical measure to reduce excess bucket expansion in the case where a hash function over-utilizes a few buckets but has good overall distribution. However, if the overall distribution gets too bad, uthash changes tactics.
Inhibited expansion
You usually don’t need to know or worry about this, particularly if you used
the keystats
utility during development to select a good hash for your keys.
A hash function may yield an uneven distribution of items across the buckets. In moderation this is not a problem. Normal bucket expansion takes place as the chain lengths grow. But when significant imbalance occurs (because the hash function is not well suited to the key domain), bucket expansion may be ineffective at reducing the chain lengths.
Imagine a very bad hash function which always puts every item in bucket 0. No matter how many times the number of buckets is doubled, the chain length of bucket 0 stays the same. In a situation like this, the best behavior is to stop expanding, and accept O(n) lookup performance. This is what uthash does. It degrades gracefully if the hash function is ill-suited to the keys.
If two consecutive bucket expansions yield ideal%
values below 50%, uthash
inhibits expansion for that hash table. Once set, the bucket expansion
inhibited flag remains in effect as long as the hash has items in it.
Inhibited expansion may cause HASH_FIND
to exhibit worse than constant-time
performance.
Hooks
You don’t need to use these hooks- they are only here if you want to modify the behavior of uthash. Hooks can be used to change how uthash allocates memory, and to run code in response to certain internal events.
malloc/free
By default this hash implementation uses malloc
and free
to manage memory.
If your application uses its own custom allocator, this hash can use them too.
#include "uthash.h"
/* undefine the defaults */
#undef uthash_malloc
#undef uthash_free
/* re-define, specifying alternate functions */
#define uthash_malloc(sz) my_malloc(sz)
#define uthash_free(ptr,sz) my_free(ptr)
...
Notice that uthash_free
receives two parameters. The sz
parameter is for
convenience on embedded platforms that manage their own memory.
Out of memory
If memory allocation fails (i.e., the malloc function returned NULL
), the
default behavior is to terminate the process by calling exit(-1)
. This can
be modified by re-defining the uthash_fatal
macro.
#undef uthash_fatal
#define uthash_fatal(msg) my_fatal_function(msg);
The fatal function should terminate the process or longjmp
back to a safe
place. Uthash does not support "returning a failure" if memory cannot be
allocated.
Internal events
There is no need for the application to set these hooks or take action in response to these events. They are mainly for diagnostic purposes.
These two hooks are "notification" hooks which get executed if uthash is expanding buckets, or setting the bucket expansion inhibited flag. Normally both of these hooks are undefined and thus compile away to nothing.
Expansion
There is a hook for the bucket expansion event.
#include "uthash.h"
#undef uthash_expand_fyi
#define uthash_expand_fyi(tbl) printf("expanded to %d buckets\n", tbl->num_buckets)
...
Expansion-inhibition
This hook can be defined to code to execute in the event that uthash decides to set the bucket expansion inhibited flag.
#include "uthash.h"
#undef uthash_noexpand_fyi
#define uthash_noexpand_fyi printf("warning: bucket expansion inhibited\n");
...
Debug mode
If a program that uses this hash is compiled with -DHASH_DEBUG=1
, a special
internal consistency-checking mode is activated. In this mode, the integrity
of the whole hash is checked following every add or delete operation. This is
for debugging the uthash software only, not for use in production code.
In the tests/
directory, running make debug
will run all the tests in
this mode.
In this mode, any internal errors in the hash data structure will cause a
message to be printed to stderr
and the program to exit.
The UT_hash_handle
data structure includes next
, prev
, hh_next
and
hh_prev
fields. The former two fields determine the "application" ordering
(that is, insertion order-- the order the items were added). The latter two
fields determine the "bucket chain" order. These link the UT_hash_handles
together in a doubly-linked list that is a bucket chain.
Checks performed in -DHASH_DEBUG=1
mode:
-
the hash is walked in its entirety twice: once in bucket order and a second time in application order
-
the total number of items encountered in both walks is checked against the stored number
-
during the walk in bucket order, each item’s
hh_prev
pointer is compared for equality with the last visited item -
during the walk in application order, each item’s
prev
pointer is compared for equality with the last visited item
Thread safety
You can use uthash in a threaded program. But you must do the locking. Use a read-write lock to protect against concurrent writes. It is ok to have concurrent readers (since uthash 1.5).
For example using pthreads you can create an rwlock like this:
pthread_rwlock_t lock;
if (pthread_rwlock_init(&lock,NULL) != 0) fatal("can't create rwlock");
Then, readers must acquire the read lock before doing any HASH_FIND
calls or
before iterating over the hash elements:
if (pthread_rwlock_rdlock(&lock) != 0) fatal("can't get rdlock");
HASH_FIND_INT(elts, &i, e);
pthread_rwlock_unlock(&lock);
Writers must acquire the exclusive write lock before doing any update. Add, delete, and sort are all updates that must be locked.
if (pthread_rwlock_wrlock(&lock) != 0) fatal("can't get wrlock");
HASH_DEL(elts, e);
pthread_rwlock_unlock(&lock);
If you prefer, you can use a mutex instead of a read-write lock, but this will reduce reader concurrency to a single thread at a time.
An example program using uthash with a read-write lock is included in
tests/threads/test1.c
.
Macro reference
Convenience macros
The convenience macros do the same thing as the generalized macros, but require fewer arguments.
In order to use the convenience macros,
-
the structure’s
UT_hash_handle
field must be namedhh
, and -
for add or find, the key field must be of type
int
orchar[]
or pointer
| macro | arguments |
|---|---|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
General macros
These macros add, find, delete and sort the items in a hash. You need to
use the general macros if your UT_hash_handle
is named something other
than hh
, or if your key’s data type isn’t int
or char[]
.
| macro | arguments |
|---|---|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Note
|
HASH_ADD_KEYPTR is used when the structure contains a pointer to the
key, rather than the key itself. |
Argument descriptions
- hh_name
-
name of the
UT_hash_handle
field in the structure. Conventionally calledhh
. - head
-
the structure pointer variable which acts as the "head" of the hash. So named because it initially points to the first item that is added to the hash.
- keyfield_name
-
the name of the key field in the structure. (In the case of a multi-field key, this is the first field of the key). If you’re new to macros, it might seem strange to pass the name of a field as a parameter. See note.
- key_len
-
the length of the key field in bytes. E.g. for an integer key, this is
sizeof(int)
, while for a string key it’sstrlen(key)
. (For a multi-field key, see the notes in this guide on calculating key length). - key_ptr
-
for
HASH_FIND
, this is a pointer to the key to look up in the hash (since it’s a pointer, you can’t directly pass a literal value here). ForHASH_ADD_KEYPTR
, this is the address of the key of the item being added. - item_ptr
-
pointer to the structure being added, deleted, or looked up, or the current pointer during iteration. This is an input parameter for
HASH_ADD
andHASH_DELETE
macros, and an output parameter forHASH_FIND
andHASH_ITER
. (When usingHASH_ITER
to iterate,tmp_item_ptr
is another variable of the same type asitem_ptr
, used internally). - replaced_item_ptr
-
used in HASH_REPLACE macros. This is an output parameter that is set to point to the replaced item (if no item is replaced it is set to NULL).
- cmp
-
pointer to comparison function which accepts two arguments (pointers to items to compare) and returns an int specifying whether the first item should sort before, equal to, or after the second item (like
strcmp
). - condition
-
a function or macro which accepts a single argument-- a void pointer to a structure, which needs to be cast to the appropriate structure type. The function or macro should return (or evaluate to) a non-zero value if the structure should be "selected" for addition to the destination hash.


src/scss/_modules/_varibles.scss
$color-primary: #868e96;
,
$color-success: #1dc9b7;
,
$color-info: #2196F3;
,
$color-warning: #ffc241;
, and
$color-danger: #b57d6a;
$color-primary: #2198F3;
,
$color-success: #69FB13;
,
$color-info: #BB1BF4;
,
$color-warning: #FF9A13;
, and
$color-danger: #FC1349;
$color-primary: #6ab5b4;
,
$color-success: #85b86c;
,
$color-info: #8f6ab5;
,
$color-warning: #e0d07e;
, and
$color-danger: #b57d6a;
$color-primary: #ff58a6;
,
$color-success: #1dc9b7;
,
$color-info: #2196F3;
,
$color-warning: #ffc241;
, and
$color-danger: #fd3995;


Want some help?
Does this page need updating?
What to expect when accessing records about you.
Look for Similar
Other Find & Connect resources
Organisation Child and Family Services Ballarat (1998 - )
- From
- 1998
- Categories
- Adoption Agency, Care Provider, Community Service Organisation and Non-denominational
- Alternative Names
- CAFS (Acronym)
- Child and Family Services Ballarat Incorporated (Legal name)
- Website
- http://www.cafs.org.au/
Summary
Child and Family Services Ballarat (CAFS) came into being in 1998. Previously, it was known as Ballarat Children's Homes and Family Services. The heritage of the organisation dates back to 1865, when the Ballarat District Orphan Asylum was established, amid great concern for the children affected by the rapid social changes of the gold rush era.
Details
Location
- 1998 -
- Child and Family Services Ballarat is situated in Ballarat. Location: Ballarat
Skip to
Related Entries
Timeline
1865 - 1909 Ballarat District Orphan Asylum
1909 - 1968 Ballarat Orphanage
1968 - 1984 Ballarat Children's Homes
1984 - 1998 Ballarat Children's Homes and Family Services
1998 - Child and Family Services Ballarat
Records managed by
Publications
Reports
- Morris, Miss Ethel, A Century of Child Care: the story of Ballarat Orphanage, 1865-1965, Ballarat Orphanage, c.1965. Details
Online Resources
- Child and Family Services Ballarat, Child and Family Services Ballarat, http://www.cafs.org.au/. Details
- 'Ballarat Orphanage and Children's Homes', in Child and Family Services Ballarat Website, Child and Family Services Ballarat, http://www.cafs.org.au/?id=ballaratorphanagebal. Details
Gallery
Sources used to compile this entry: 'Ballarat Orphanage and Children's Homes', in Child and Family Services Ballarat Website, Child and Family Services Ballarat, http://www.cafs.org.au/?id=ballaratorphanagebal.
Prepared by: Cate O'Neill
Created: 30 January 2009, Last modified: 28 October 2011


Cards
Default card
Card content
Cards also has footers
Header as an element!
Content!
Footer!
Loading card
bb-section-content events: {{sectionEvents | json}}
Header!
Content!!!
Footer!!!
Errored card
bb-section-content events: {{sectionEvents | json}}
Header!
Content!!!
Footer!!!
Card group
Content!!!
Footer!!!
Content!!!
Footer!!!
Content!!!
Footer!!!
Collapsable card
Toogle: {{toogles | json}}
Content!!!
This is the footer!
Content!!!
This is the footer with custom background!
NOTE: Collapsable cards cannot be grouped.
Collapsable card (remember)
MOAR Content!!!
NOTE: Save in localStorage it's state
Condense vs normal card


Functions using Cohen's effect sizes (Cohen, Jacob. Statistical power analysis for the behavioral sciences. Academic press, 2013) are provided for reliable feature selection in biology data analysis. In addition to Cohen's effect sizes, p-values are calculated and adjusted from quasi-Poisson GLM, negative binomial GLM and Normal distribution ANOVA. Significant features (genes, RNAs or proteins) are selected by adjusted p-value and minimum Cohen's effect sizes, calculated to keep certain level of statistical power of biology data analysis given p-value threshold and sample size.
| Version: | 1.0.1 |
| Depends: | R (≥ 3.1.0), pwr, MASS, plyr, ggplot2 |
| Published: | 2015-06-23 |
| Author: | Lang Ho Lee, Arnold Saxton, Nathan Verberkmoes |
| Maintainer: | Lang Ho Lee <langholee at gmail.com> |
| License: | GPL-2 |
| NeedsCompilation: | no |
| CRAN checks: | selfea results |
| Reference manual: | selfea.pdf |
| Package source: | selfea_1.0.1.tar.gz |
| Windows binaries: | r-devel: selfea_1.0.1.zip, r-release: selfea_1.0.1.zip, r-oldrel: selfea_1.0.1.zip |
| OS X binaries: | r-release: selfea_1.0.1.tgz, r-oldrel: selfea_1.0.1.tgz |
| Old sources: | selfea archive |
Please use the canonical form https://CRAN.R-project.org/package=selfea to link to this page.


Sport weekend
Active weekend is here. Join us!
Fitness tour
Active weekend is here. Join us!
Healthy food
Active weekend is here. Join us!
Children, sports and exercise
Children's sports promote fitness, but not everyone thrives in formal. Help your child find the right activities and venue — school, recreation center or backyard.
How to get into running
Running is for everyone. It is the perfect way to get active - it's free and you can start right outside your front door. Comfortable sports clothing and a suitable pair of trainers is all you need.
Gymsport
In this day in age, keeping fit has become one of the top activities for someone to do in their free time. A popular way to stay in shape is by going to the gym, with multiple different types of workouts you can do, from weight lifting to light cardio.
Winter sport
Children's sports promote fitness, but not everyone thrives in formal leagues. Help your child find the right activities and venue — school, recreation center or backyard.
Winter running
Running is for everyone. It is the perfect way to get active - it's free and you can start right outside your front door. Comfortable sports clothing and a suitable pair of trainers is all you need.
Tennis
In this day in age, keeping fit has become one of the top activities for someone to do in their free time. A popular way to stay in shape is by going to the gym, with multiple different types of workouts you can do, from weight lifting to light cardio.
Lorem ipsum dolor sit amet consectetur, adipisicing elit. Ex, cumque sit voluptas in neque necessitatibus exercitationem suscipit veniam blanditiis, architecto doloremque sequi temporibus consectetur facere assumenda distinctio tenetur.


Test app for ng-repeat-infinity
https://github.com/RobertjanTuit/ng-repeat-infinity
Loading app with 2 x 10000 ng-repeat rows...
Last reload:
seconds ago.
Angular app rendering 2 x 10000 rows took:
seconds.
ms per 100 rows
List numbers test:
{{ item.label }}
{{ item.label }}


| OLD line(s): 172
<xsd:include schemaLocation="../../CorporateIncomeTax/Common/IRS970/OtherGoodsInventoryAndLIFOMethodExplnStatement.xsd" /> | NEW line(s): 172
<xsd:include schemaLocation="../../CorporateIncomeTax/Common/IRS970/OtherDollarValueMethodUsedExplnStatement.xsd" /> |
| OLD line(s): 173
| NEW line(s): 174
<xsd:include schemaLocation="../../CorporateIncomeTax/Common/IRS970/OtherGoodsInventoryAndLIFOMethodExplnStatement.xsd" /> |
| OLD line(s): 363,365
<!-- Includes for 8820 (supporting info, schedules, computations, and such) --> <xsd:include schemaLocation="../../CorporateIncomeTax/Common/IRS8820/OrphanDrugStatement.xsd" /> | NEW line(s): 363
|
| OLD line(s): 468,470
<!-- Includes for 8882 (supporting info, schedules, computations, and such) --> <xsd:include schemaLocation="../../CorporateIncomeTax/Common/IRS8882/CreditFromPassThroughEntitiesStatement.xsd"/> | NEW line(s): 465
|
| OLD line(s): 605
<xsd:element ref="IRS990ScheduleO" minOccurs="1"> | NEW line(s): 600
<xsd:element ref="IRS990ScheduleO" minOccurs="0"> |
| OLD line(s): 1290
| NEW line(s): 1286,1292
<xsd:element ref="OtherDollarValueMthdUsedExpln" minOccurs="0" maxOccurs="unbounded"> <xsd:annotation> <xsd:documentation>Explanation For Other Dollar Value Method Used To Figure The Current Year Cost Of Goods Sold</xsd:documentation> </xsd:annotation> </xsd:element> <!-- Form 970 statement --> |
| OLD line(s): 2354,2360
<!-- Form 8820 statement --> <xsd:element ref="OrphanDrugStatement" minOccurs="0" maxOccurs="unbounded"> <xsd:annotation> <xsd:documentation>Orphan Drug Statement</xsd:documentation> </xsd:annotation> </xsd:element> | NEW line(s): 2355
|
| OLD line(s): 3102,3108
<!-- Form 8882 statement --> <xsd:element ref="CreditFromPassThruEntitiesStmt" minOccurs="0" maxOccurs="unbounded"> <xsd:annotation> <xsd:documentation>Credit From Pass-Through Entities Statement</xsd:documentation> </xsd:annotation> </xsd:element> | NEW line(s): 3096
|


SpongeBob SquarePants
image source.
124 conch street
Bikini Bottom, Bikini Atoll 96960
shell phone:<PHONE_NUMBER>
<EMAIL_ADDRESS>Education
The Oshin Institue of Culinary Arts
- Nemo School of Fry Cooking
- Overall GPA: 3.0
Experience
Krusty Krab
- Uphold positive relationships with guests and Squidward
- Efficiently prepare deliceous Krabby Patties for guests
- Annoy Squidward
Here's a link to how I make delicious Crying Jonnny Crying Jonnny.


{% block content %}
The data used here was made open source by Facebook AI research. bAbI dataset was created by Facebook towards the goal of automatic text understanding and reasoning. It is a set of 20 QA tasks, each consisting of several context-question-answer triplets. Each task aims to test a unique aspect of reasoning and is, therefore, geared towards testing a specific capability of QA learning models..
This model has two modules
The memory module has the story we want to tell written as vectors. Since computers cannot understand words, we need to convert words into numbers/vectors. Instead of just converting every word to a number, we use a technique called embedding which gives words with similar meanings similar vectors. For example since the words “pick up” or “lift” have similar meaning they will have similar vectors and it helps the machine better understand the context between words. Tensorflow embeddings functionality can be used for generating word to vectors.


Concepts
Edit (pull request)Alien 4 Cloud is a DevOps tool that allows people in the enterprise to collaborate in order to provide self-service deployment of complex applications taking in account the different experts through a role based portal.
Alien 4 Cloud want to provide self-service no only for users but also for development teams that want to build and deploy complex applications and leverage cloud resources to deploy their environments in minutes.
In order to provide enterprise self-service portal, alien 4 cloud leverages the following concept:
- Location: Deployment target (cloud, set of physical machines or virtual machines)
- Components: Software components to deploy
- Topologies: Description of multiple software components assembled together (to build an application).
- Applications: Actual applications to deploy with environments and versions each of them being associated with a topology.
- TOSCA: An emerging standard to describe service components and their relationships
On top of these notions Alien 4 Cloud provide a comprehensive set of roles that can be mapped in flexible manners to the people and structure of an enterprise IT department.
Edit (pull request)


This application demonstrates leveraging the Microsoft Graph to show messages from your Deleted Items folder in Office 365 and Azure AD applications in an Angular application. It also demonstrates how to page through large datasets with Angular & the Microsoft Graph.


Automating an application¶
Once you have installed pywinauto - how do you get going?
Sit back and have a look at a little movie¶
Jeff Winkler has created a nice screencast of using pywinauto, you can see it at :
Look at the examples¶
The following examples are included: Note: Examples are language dependent - they will only work on the language of product that they were programmed for. All examples have been programmed for English Software except where highlighted.
mspaint.py
Control MSPaintnotepad_fast.py
Use fast timing settings to control Notepadnotepad_slow.py
Use slow timing settings to control Notepadnotepad_item.py
Use item rather then attribute access to control Notepad.MiscExamples.py
Show some exceptions and how to get control identifiers.SaveFromInternetExplorer.py
Save a Web Page from Internet Explorer -SaveFromFirefox.py
Save a Web Page from Firefox.get_winrar_info.py
Example of how to do multilingual automation. This is not an ideal example (works on French, Czech and German WinRar)ForteAgentSample.py
Example of dealing with a complex application that is quite dynamic and gives different dialogs often when starting.windowmediaplayer.py
Just another example - deals with check boxes in a ListView.test_sakura.py
,test_sakura2.py
Two examples of automating a Japanase product.
Automate notepad at the command line¶
Please find below a sample run
C:\>python
Python 2.4.2 (#67, Sep 28 2005, 12:41:11) [MSC v.1310 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
(1) >>> from pywinauto import application
(2) >>> app = application.Application()
(3) >>> app.Start_("Notepad.exe")
<pywinauto.application.Application object at 0x00AE0990>
(4) >>> app.Notepad.DrawOutline()
(5) >>> app.Notepad.MenuSelect("Edit -> Replace")
(6) >>> app.Replace.PrintControlIdentifiers()
Control Identifiers:
Static - 'Fi&nd what:' (L1018, T159, R1090, B172)
'Fi&nd what:' 'Fi&nd what:Static' 'Static' 'Static0' 'Static1'
Edit - '' (L1093, T155, R1264, B175)
'Edit' 'Edit0' 'Edit1' 'Fi&nd what:Edit'
Static - 'Re&place with:' (L1018, T186, R1090, B199)
'Re&place with:' 'Re&place with:Static' 'Static2'
Edit - '' (L1093, T183, R1264, B203)
'Edit2' 'Re&place with:Edit'
Button - 'Match &case' (L1020, T245, R1109, B265)
'CheckBox2' 'Match &case' 'Match &caseCheckBox'
Button - '&Find Next' (L1273, T151, R1348, B174)
'&Find Next' '&Find NextButton' 'Button' 'Button0' 'Button1'
Button - '&Replace' (L1273, T178, R1348, B201)
'&Replace' '&ReplaceButton' 'Button2'
Button - 'Replace &All' (L1273, T206, R1348, B229)
'Button3' 'Replace &All' 'Replace &AllButton'
Button - 'Cancel' (L1273, T233, R1348, B256)
'Button4' 'Cancel' 'CancelButton'
(7) >>> app.Replace.Cancel.Click()
(8) >>> app.Notepad.Edit.TypeKeys("Hi from Python interactive prompt %s" % str(dir()), with_spaces = True)
<pywinauto.controls.win32_controls.EditWrapper object at 0x00DDC2D0>
(9) >>> app.Notepad.MenuSelect("File -> Exit")
(10) >>> app.Notepad.No.Click()
>>>
Import the pywinauto.application module (usually the only module you need to import directly)
Create an Application instance. All access to the application is done through this object.
We have created an Application instance in step 2 but we did not supply any information on the Windows application it referred to. By using the Start_() method we execute that application and connect it to the Application instance app.
Draw a green rectangle around the Notepad dialog - so that we know we have the correct window.
Select the Replace item from the Edit Menu on the Notepad Dialog of the application that app is connected to. This action will make the Replace dialog appear.
Print the identifiers for the controls on the Replace dialog, for example the 1st edit control on the Replace dialog can be referred to by any of the following identifiers:
app.Replace.Edit app.Replace.Edit0 app.Replace.Edit1 app.FindwhatEdit
The last is the one that gives the user reading the script aftewards the best idea of what the script does.
Close the Replace dialog. (In a script file it is safer to use CloseClick() rather than Click() because CloseClick() waits a little longer to give windows time to close the dialog.)
Let’s type some text into the Notepad text area. Without the
with_spaces
argument spaces would not be typed. Please see documentation for SendKeys for this method as it is a thin wrapper around SendKeys.Ask to exit Notepad
We will be asked if we want to save - Click on the “No” button.


Home
Training Information
Outstanding Training
Log Out
Welcome {{userName}}
Training Details Search Page
Product Name
Date Completed
Outcome Status
Type Of Assessment
« Prev
Next »


Kelly Hutchins
Tao Zhang
slides: https://arcg.is/08yqfD0
https://arcg.is/08yqfD0
https://arcg.is/1O5u09
https://arcg.is/0Hv8Cn
Tab order should match intended reading order.
When you use `` element, you get a lot of functionality for free:
Reference: ARIA Best Practices - Dialog


Etcd servers you want KrakenD to make use of for host resolution
http(s)://hostname[:port]
Dial timeout includes name resolution.
KeepAlive specifies the keep-alive period for an active network connection. If zero, keep-alives are not enabled.
Header sent to determine the maximum timeout per request
Absolute path to the certificate
Absolute path to the private key
Absolute path to the CA Cert


Volkswagen to focus on SUVs for Indian market
by Team ODSUVs have always been the most popular body type in India, encouraging different automobile manufacturers to churn out more SUVs / SUV-like offerings. German car manufacturer Volkswagen has now stated that the all-new offerings that it plans to launch next in the country will be an SUV. This update comes in when the company is planning to regain its lost market share that has gone below 1 per cent. While it will continue to offer the existing products and will also introduce periodic face lifts, VW India will be banking on SUVs for its future growth in the country. The company will launch the T-Roc and T-Cross from next year onward.
In an interview with livemint, Steffen Knapp, director, Volkswagen Passenger Cars, a division of VW Group Sales India Pvt. Ltd mentioned, "We will transform Volkswagen into an SUV brand in India,". The company's wholesale figures stand at 34,859 units which amounts to 1 per cent of the country's total passenger car market. And the same for Skoda Auto is less that 0.5 per cent. "We will continue to sell the existing cars here, will replace them time to time (with new face-lifts), but the additional products that we plan to bring will only be SUVs. That's because I see this trend of rising demand for SUVs in the local market here. I believe that the SUV is the car for India more than any other country in the world," Knapp told livemint.
Read:
2019 Volkswagen T-Roc first drive review
Image gallery: 2019 Volkswagen T-Roc R
Earlier this year, Skoda India and Volkswagen Group India today unveiled a new technology center at it's production facility in Chakan, Pune. The center is a major development in it's India 2.0 plan which aims to Garner five per cent market share in India. This center is part of the EUR 250 million the group will invest in R and D for the Skoda led 2.0 plan. The first project being taken up here is the development of the India-specific MQB A0 IN. The 250 Indian engineers employed at this center will work on project management, electronics, infotainment, body design, interior, chassis and complete vehicle. The platform will see up to 95% localization.
The overall investment for India 2.0 will cross the EUR 1 billion mark. A concept based on this platform will debut at the 2020 Auto Expo. This will be a small SUV, possibly under sub-four-metres. The group promises that customer service will take a step forward with this plan, prices too will drop. Volkswagen will launch the T-Roc in India.
Also read,
India-bound Volkswagen T-Cross 1.0 TSI first drive review
2019 Volkswagen T-Cross makes global debut, India launch expected in 2020


A simple AngularJS (1.x) example code of lazy loading modules, using UI-Router (and Extras), ocLazyLoad and Webpack!
UI-Router
ocLazyLoad
Webpack


NumberOfItems
Set of rules that analyse the number of items in a segment of code, for example the number of members in a class.
Rules
MaxNumberOfFunctionParameters - FS0052
Cause
A function contains more than a configurable number of parameters, for example if maxItems
was set to 5 (the default value)
then the following condition would cause the error: let findCat one two three four five six = 0
Rationale
Too many parameters make the function difficult to use.
How To Fix
Reduce the number of function parameters, e.g. to fix the example in the "Cause": let findCat one two three four five = 0
. A good way to reduce the number of parameters is to group them using records.
Rule Settings
enabled
- A boolean property that can enable and disable this rule. (Default true)
maxItems
- An integer property that specifies the max number of function parameters. (Default 5)
MaxNumberOfMembers - FS0053
Cause
A class contains more than a configurable number of members (maxItems
).
Rationale
The class is likely to be doing too much and violating the single responsibility principle.
How To Fix
Reduce the number of members in the class, e.g. extract them out to another class.
Rule Settings
enabled
- A boolean property that can enable and disable this rule. (Default true)
maxItems
- An integer property that specifies the max number of members in a class. (Default 32)
MaxNumberOfItemsInTuple - FS0051
Cause
A tuple contains more than a configurable number of items, for example if maxItems
was set to 4 (the default value)
then the following statement would cause the error: let tup = (1, 2, 3, 5, 6)
Rationale
Tuple's items are not named, the more items there are the harder it is to work out what each is for.
How To Fix
Reduce the number of items in the tuple, ideally replace the tuple with a record.
Rule Settings
enabled
- A boolean property that can enable and disable this rule. (Default true)
maxItems
- An integer property that specifies the max number of items in a tuple. (Default 4)
MaxNumberOfBooleanOperatorsInCondition - FS0054
Cause
A while/if/assert/match when
condition contains more than a configurable number of boolean operators, for example if maxItems
was set to 4 (the default value)
then the following condition would cause the error: if x && y || q || r && t && w then
Rationale
Can make the control flow become diffcult to understand.
How To Fix
Reduce the number of boolean operators in the while/if/assert/match when
condition, e.g. a simple way to fix the example in the "Cause" section you could name the expression:
1: 2: |
|
Rule Settings
enabled
- A boolean property that can enable and disable this rule. (Default true)
maxItems
- An integer property that specifies the max number of boolean operators in a condition. (Default 4)
Full name: NumberOfItems.catIsInBin


Beautiful Beaches has many opportunities for activities such as scuba diving, snorkeling, surfing and swimming. We have a tennis court, golf course and hot tub on site. Every night there are nightlife activities going on in the city, which is walking distance from the rooms. Check here for some pictures from a recent scuba trip


{% extends "voting/main.html" %} {% load static %} {% block title %} BlockVote {% endblock %} {% block body %}
Voter {{ voter }}
You have voted candidate {{ cand }}


| Interface | Description |
|---|---|
| GVTTreeBuilderListener |
This interface represents a listener to the GVTTreeBuilderEvent events.
|
| LinkActivationListener |
This interface represents a listener to the LinkActivationEvent events.
|
| SVGDocumentLoaderListener |
This interface represents a listener to the SVGDocumentLoaderEvent events.
|
| SVGLoadEventDispatcherListener |
This interface represents a listener to the
SVGLoadEventDispatcherEvent events.
|
| SVGUserAgent |
This interface must be implemented to provide client services to
a JSVGComponent.
|
| Class | Description |
|---|---|
| GVTTreeBuilder |
This class represents an object which builds asynchroneaously
a GVT tree.
|
| GVTTreeBuilderAdapter |
An adapter class that represents a listener to the GVTTreeBuilderEvent
events.
|
| GVTTreeBuilderEvent |
This class represents an event which indicate an event originated
from a GVTTreeBuilder instance.
|
| JSVGComponent |
This class represents a swing component that can display SVG documents.
|
| JSVGComponent.BridgeUserAgentWrapper |
The user-agent wrapper, which call the methods in the event thread.
|
| LinkActivationEvent |
This class represents an event which indicate an event originated
from a GVTTreeBuilder instance.
|
| Messages |
This class manages the message for the css.engine module.
|
| SVGDocumentLoader |
This class represents an object which loads asynchroneaously a SVG document.
|
| SVGDocumentLoaderAdapter |
An adapter class that represents a listener to the
SVGDocumentLoaderEvent events. |
| SVGDocumentLoaderEvent |
This class represents an event which indicate an event originated
from a SVGDocumentLoader instance.
|
| SVGFileFilter |
This implementation of FileFilter will allows SVG files
with extention '.svg' or '.svgz'.
|
| SVGLoadEventDispatcher |
This class dispatches the SVGLoadEvent event on a SVG document.
|
| SVGLoadEventDispatcherAdapter |
This class provides an adapter for the SVGLoadEventDispatcherListener
interface.
|
| SVGLoadEventDispatcherEvent |
This class represents an event which indicate an event originated
from a SVGLoadEventDispatcher instance.
|
| SVGUpdateOverlay |
One line Class Desc
Complete Class Desc
|
| SVGUserAgentAdapter |
This Implements the SVGUserAgent interface to provide a very simple
version of client services to the JSVGComponent.
|
| SVGUserAgentGUIAdapter |
One line Class Desc
Methods users may want to implement:
displayMessage
|
Copyright © 2022 Apache Software Foundation. All Rights Reserved.


Rendering Examples
Path tracing, Global Illumination
Ray Marching Volumetri, Brain
Ray Marching, Metaball
Ray Trace, Noise and Fog
Sphere Trace, Julia set
Inceremental Phong Illumination
Inceremental, 2D Space shooter


| Name |
Date Joined |
# Items Contributed |
# Collections |
|
| D'Igmond, Gus |
6/22/11 |
12 |
1 |
|
| Donnelly, Joe |
9/21/12 |
275 |
67 |
|
| Dwight, Sandra |
10/2/11 |
0 |
0 |
|
| D'Igmond, Gus admin |
6/22/11 |
12 |
1 |
|
| Donnelly, Joe |
9/21/12 |
275 |
67 |
|
| Dwight, Sandra |
10/2/11 |
0 |
0 |
|
| D'Igmond, Gus |
6/22/11 |
12 |
1 |
|
| Donnelly, Joe |
9/21/12 |
275 |
67 |
|
| Dwight, Sandra |
10/2/11 |
0 |
0 |
|
| D'Igmond, Gus |
6/22/11 |
12 |
1 |
|
| Donnelly, Joe |
9/21/12 |
275 |
67 |
|
| Dwight, Sandra admin |
10/2/11 |
0 |
0 |
|
| D'Igmond, Gus |
6/22/11 |
12 |
1 |
|
| Donnelly, Joe |
9/21/12 |
275 |
67 |
|
| Dwight, Sandra |
10/2/11 |
0 |
0 |
|
| D'Igmond, Gus |
6/22/11 |
12 |
1 |
|
| Donnelly, Joe |
9/21/12 |
275 |
67 |
|
| Dwight, Sandra |
10/2/11 |
0 |
0 |
|
| D'Igmond, Gus |
6/22/11 |
12 |
1 |
|
| Donnelly, Joe |
9/21/12 |
275 |
67 |
|
| Dwight, Sandra |
10/2/11 |
0 |
0 |
|
| D'Igmond, Gus |
6/22/11 |
12 |
1 |
|
| Donnelly, Joe |
9/21/12 |
275 |
67 |
|
| Dwight, Sandra |
10/2/11 |
0 |
0 |
|
| D'Igmond, Gus |
6/22/11 |
12 |
1 |
|
| Donnelly, Joe |
9/21/12 |
275 |
67 |
|
| Dwight, Sandra |
10/2/11 |
0 |
0 |
|
| D'Igmond, Gus |
6/22/11 |
12 |
1 |
|
| Donnelly, Joe |
9/21/12 |
275 |
67 |
|
| Dwight, Sandra |
10/2/11 |
0 |
0 |
|
| D'Igmond, Gus |
6/22/11 |
12 |
1 |
|
| Donnelly, Joe |
9/21/12 |
275 |
67 |
|
| Dwight, Sandra |
10/2/11 |
0 |
0 |
|


This December, we are going to a School in Lagos, to organize a Hour of Code, marking our first official event and launch. The Hour of Code is an annual worldwide event initiated by code.org to demystify and introduce computer science to children of all ages. This December event is proudly supported by the nigerian child initiative.


Tera Term Help Index
Copyright (C) 1994-1998 T. Teranishi
(C) 2004-2019 TeraTerm Project
All Rights Reserved.
Tera Term is a free software terminal emulator (communication program) which supports:
- Serial port connections.
- TCP/IP (telnet, SSH1, SSH2) connections.
- Log replaying.
- Named pipe connection.
- IPv6 communication.
- VT100 emulation and selected VT200/300 emulation.
- TEK4010 emulation.
- File transfer protocols (Kermit, XMODEM, YMODEM, ZMODEM, B-PLUS and Quick-VAN).
- Scripts using the "Tera Term Language".
- Japanese, English, Russian, Korean and UTF-8 character sets.
- UTF-8 character encoding.
- Message catalog(Japanese, English, German, French, Russian, Korean and Chinese).
About Tera Term
Usage
VT window commands
TEK window commands
Command line
Setup files
Reference data


| 1 | Computer Fundamentals |
| 2 | Problem Solving and Programming in C |
| 3 | Digital Logic & Computer Design |
| 4 | Mathematica & Matlab |
| 5 | Professional and Business Communications |
| 6 | Principles of Mgmt. and Organizational Behaviour |
| 1 | Operating System and Shell Programming |
| 2 | Object Oriented Programming in C++ |
| 3 | Data & File Structures |
| 4 | Microprocessor & Computer Architecture |
| 5 | System Analysis and Design |
| 6 | Theory of Computations |
| 1 | Advance Problem Solving using Java |
| 2 | DBMS with Oracle Based Programming |
| 3 | Software Engineering with Minor Project |
| 4 | Analysis and Design of Algorithm |
| 5 | Computer Network and System Administration |
| 6 | Scientific and Statistical Techniques using Fortran |
| 1 | Web Based Development using J2EE |
| 2 | Artificial Intelligence and Prolog Programming |
| 3 | Software Project Management with Minor Project |
| 4 | Big Data Analytics and Cloud Computing |
| 5 | Leadership, Interpersonal and Group Dynamics |
| 6 | Elective-I |
| 1 | Digital Image Processing and GPU Programming |
| 2 | Data Mining and Data Warehousing |
| 3 | Machine Learning and Soft Computing |
| 4 | Pattern Matching using Python Programming |
| 5 | Elective-II |
| 6 | Elective-III |
| Industrial Project (Capstone Course) |
| 1 | Elective-I : Advance Database Management System, Cryptography |
| 2 | Elective-II : Principles of Pogramming languages |
| 3 | Elective-III : Web and ECommerce |


Login
Logout
Transfer
Call Contract
Vote
Generate Key
Query Account By Name
Get Balance
getIdentity
Check Extension
Check Native Dep
getArbitrarySignature


Lorem Ipsum is the dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book.
It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged.
Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident.
Lorem Ipsum is the dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book.
It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged.


The Orion Nebula is also known as M42. Look into the night sky at the constellation of Orion. Now locate the middle “star” in the “sword” of Orion. You’ve found the pictured nebula!


Mipui Game Master Tools
When a user loads a Mipui map, that can either be in read/write mode (in which case the address looks like /index.html?mid=something&secret=something) or read-only mode (in which case the address lacks the &secret=something part). GM tools appear differently in the two modes.
The hide / reveal tools will overlay the cell with solid black in read-only mode, and translucent overlay in read/write mode. The basic tool will just show/hide a single cell, but there are buttons to show/hide the entire map, and a tool which reveals all cells in line of sight from the selected cell.
The GM note, hidden secret door, Region and Hidden passage tools will create elements which are only visible in read/write mode.
GM tools are not cheat-proof. The data is sent from the server, it's just not displayed to the user - so it's still possible to access it. Don't rely on it if you can't trust your viewers to not cheat.


|
|
datacode woes between Arduino & Pi |
14 |
2 years 27 weeks ago by normosb |
1 year 48 weeks ago by hneel |
|
|
multiuser - 3 tier emoncms application |
6 |
2 years 35 weeks ago by brisco |
1 year 48 weeks ago by pb66 |
|
|
Almost there... DNS problem |
15 |
2 years 38 weeks ago by Thijs |
1 year 47 weeks ago by christophe_meyers |
|
|
emonTx V3 CT1234 + 3-phase Voltage example |
3 |
1 year 47 weeks ago by Eric_AMANN |
1 year 47 weeks ago by Robert Wall |
|
|
EmonCMS User permission/privilege assignment module |
9 |
1 year 48 weeks ago by Mandela |
1 year 47 weeks ago by Mandela |
|
|
emonTx V3.4 firmware with interrupt pulse counting |
18 |
1 year 48 weeks ago by glyn.hudson |
1 year 47 weeks ago by dkcsn |
|
|
Dashboard - Problem Widgets --> Feedvalue |
1 |
1 year 47 weeks ago by krabu |
1 year 47 weeks ago by pb66 |
|
|
read multiple 1-wire sensors from emonTx terminal |
23 |
1 year 48 weeks ago by alex88 |
1 year 47 weeks ago by Robert Wall |
|
|
needed changes in process_model for resend data |
0 |
1 year 47 weeks ago by mpruessmeier |
n/a |
|
|
about EmonHub |
1 |
1 year 47 weeks ago by lolah |
1 year 47 weeks ago by pb66 |
|
|
Data lost |
0 |
1 year 47 weeks ago by pimmernl |
n/a |
|
|
Development: Calculating Wh totals on the emontx |
15 |
2 years 50 weeks ago by TrystanLea |
1 year 47 weeks ago by chaveiro |
|
|
Local EmonCMS server died (old version) Upgrade to new help |
4 |
2 years 34 weeks ago by manicmoddin |
1 year 47 weeks ago by manicmoddin |
|
|
emonCMS send failure: wanted 'ok' but got '<br /> |
5 |
1 year 47 weeks ago by alex88 |
1 year 47 weeks ago by alex88 |
|
|
Timeout Variable |
1 |
1 year 47 weeks ago by F_EEE |
1 year 47 weeks ago by Robert Wall |
|
|
Testing the next version of emoncms v8.5 |
16 |
1 year 47 weeks ago by TrystanLea |
1 year 47 weeks ago by chaveiro |
|
|
emonTx V3 GitHub re-organise |
1 |
1 year 46 weeks ago by glyn.hudson |
1 year 46 weeks ago by Robert Wall |
|
|
Duty Cycle and data posting |
1 |
1 year 46 weeks ago by piperpilot |
1 year 46 weeks ago by Robert Wall |
|
|
Emoncms Event module |
58 |
4 years 9 weeks ago by Guest |
1 year 46 weeks ago by Mandela |
|
|
Feed update time? |
4 |
1 year 46 weeks ago by Larsjo |
1 year 46 weeks ago by Larsjo |
|
|
Number of Digits Displaying in "My Electric:" |
1 |
1 year 46 weeks ago by officeboy |
1 year 46 weeks ago by officeboy |
|
|
Lost EmonCMS process list and feedvalue control values |
2 |
3 years 1 day ago by pb66 |
1 year 46 weeks ago by Larsjo |
|
|
EmonCMS - cannot export csv from MYSQL feeds |
1 |
1 year 47 weeks ago by mpruessmeier |
1 year 46 weeks ago by mpruessmeier |
|
|
RFM69cw data transmissions not getting through |
7 |
1 year 46 weeks ago by nrgbod |
1 year 46 weeks ago by Robert Wall |
|
|
Trying to upgrade old HDD pi installation |
3 |
1 year 46 weeks ago by borpin123 |
1 year 45 weeks ago by borpin123 |
|
|
Delete wrong data |
1 |
1 year 45 weeks ago by unique24 |
1 year 45 weeks ago by unique24 |
|
|
Something changed in My Electric app |
7 |
1 year 50 weeks ago by ondrej1024 |
1 year 45 weeks ago by Paul Reed |
|
|
Feed engine |
6 |
2 years 3 weeks ago by eugen66 |
1 year 45 weeks ago by pb |
|
|
2 charts from same feed, but different day |
1 |
1 year 46 weeks ago by unique24 |
1 year 45 weeks ago by Larsjo |
|
|
RFM2pi data not appearing in Inputs list |
7 |
1 year 45 weeks ago by vester |
1 year 44 weeks ago by pb66 |
|
|
emonSD-13-03-15.img read-only root partition |
7 |
1 year 44 weeks ago by BraileTrail |
1 year 44 weeks ago by BraileTrail |
|
|
emonhub limited to 32 nodes |
1 |
1 year 44 weeks ago by coldpenguin |
1 year 44 weeks ago by pb66 |
|
|
EmonCMS Touch support |
1 |
1 year 44 weeks ago by chaveiro |
1 year 44 weeks ago by JD |
|
|
How to distinguish between current transformers in the emonhub configuration file? |
2 |
1 year 47 weeks ago by xzuttz |
1 year 44 weeks ago by xzuttz |
|
|
Verify RFM69Pi |
11 |
1 year 46 weeks ago by haden |
1 year 44 weeks ago by haden |
|
|
emoncms.org not updating inputs |
6 |
1 year 44 weeks ago by warlock |
1 year 44 weeks ago by warlock |
|
|
Module "event" error |
5 |
2 years 43 weeks ago by unique24 |
1 year 44 weeks ago by Bruno |
|
|
Raspberry PI Emoncms - Starting from scratch, Which method |
6 |
1 year 44 weeks ago by Keith Drayton |
1 year 44 weeks ago by Bill Thomson |
|
|
A feed to capture other feeds |
10 |
1 year 46 weeks ago by coldpenguin |
1 year 44 weeks ago by coldpenguin |
|
|
String that data in mysql database |
2 |
1 year 44 weeks ago by Mkj |
1 year 44 weeks ago by Mkj |
|
|
Create Feed to control LED widget |
6 |
1 year 44 weeks ago by bruce_miranda |
1 year 44 weeks ago by bruce_miranda |
|
|
Viewing public dashboard on emoncms.org |
3 |
3 years 39 weeks ago by engeeaitch |
1 year 43 weeks ago by bruce_miranda |
|
|
Install on provider |
2 |
1 year 44 weeks ago by unique24 |
1 year 43 weeks ago by unique24 |
|
|
Big difference in power displayed between Solar Inverter and emontx |
6 |
1 year 44 weeks ago by bruce_miranda |
1 year 43 weeks ago by bruce_miranda |
|
|
Recording and displaying kWh, kWh/d, kWh/m |
6 |
1 year 44 weeks ago by craigfryer |
1 year 43 weeks ago by craigfryer |
|
|
EmonTX via CT reporting 28W when it should be zero |
2 |
1 year 43 weeks ago by craigfryer |
1 year 43 weeks ago by craigfryer |
|
|
Json bulk date wrong |
2 |
1 year 43 weeks ago by unique24 |
1 year 43 weeks ago by unique24 |
|
|
Typo in bufferedwrite install instructions |
2 |
1 year 44 weeks ago by pb |
1 year 43 weeks ago by TrystanLea |
|
|
Only PHPTIMESERIES working (not PHPFIWA nor PHPFINA) |
9 |
2 years 1 week ago by ChuliaLT |
1 year 43 weeks ago by ChuliaLT |
|
|
Remotely Update Raspberry Pi's |
4 |
1 year 43 weeks ago by glyn.hudson |
1 year 43 weeks ago by alexandros |


Article number: {{post_info.0}}; author: {{post_info.1}}; subject: {{post_info.2}}; article length: {{post_info.3}}
{% set count = count + 1 %}
{% endfor %}
{% endif %}
{% if posts %}
Newsgroup '{{newsgroup}}' articles (click on an article to see its contents):
{% set count = 0 %} {% for post_info in posts %}


{{choose.label}}
Let us help you define your project.
choose
your options by clicking on the
button
I need {{chosen.type}} to do {{chosen.field}} with {{chosen.attributes}}
{{skills}}


{% load static %}
ConsensusIO is a finance-based news aggregation platform using natural language processing to classify news articles about a given security into one of four discrete classes: positive, indifferent, negative, and not financial. When supplied with a large batch of articles, ConsensusIO gives a pulse on markets regarding the sentiment of a given company.
Sentiment analysis is considered a natural language processing problem. At its core, natural language processing (NLP) boils down into two subproblems:
All model hyperparameters were optimized via a grid search using 20-fold cross validation. The preprocessing pipeline for all models consisted of word-stemming, HTML and punctuation removal, and shifting text to lower case. The train/test split used was 0.1.
The news_sentiment model classifies financial articles into one of three discrete categories: positive, indifferent, or negative. For production, a SGD model with tf-idf encoding and supervised weighting was used.
fin_not_fin filters down from all news to financial news by classifying news as either financial or not financial. Due to the general purpose use of the NewsAPI, much of the news gathered on queries for companies such as “Amazon” are about hot deals rather than stock prices, thereby a model must be trained to filter out these articles. For production, a SGD model with tf-idf encoding and supervised weighting was used.
Two models were used due to the prevalence of data for one problem, and the scarcity of data for the other. In the case of fin_not_fin, one can easily find large amounts of labeled training data; one must simply find financial news for one group, and any other news for the other group. Meanwhile, the news_sentiment model relied upon the highly intensive and laborious process of a hand labeling a training data set. Programmatic document creation was employed to lessen this task.
While the BERT model performs the best, the computation time to retrain the model and encode data is significantly greater than that of simpler models. Therefore, running these models on pythonanywhere hardware would significantly slow down the site. While it is possible to run these models quickly and efficiently using Cloud TPUs via the Google Cloud API, this was not accomplished due to time constraints.
Yes, 0.64 accuracy is terrible! This stems from the extremely small training set to predict hyper-complex inputs with literally thousands of dimensions. Unfortunately, even with transfer learning, one cannot “model” their way out of a small dataset. This is where ConsensusIO’s incremental learning comes in. The more one corrects articles, the better the platform becomes! By the time you read this, the platform’s prediction is most likely better than 0.64.
The two main delays in loading a page come from querying the two APIs and transforming the dataset for the ML models. Therefore, when a company is searched, the platform stores the gathered information and ML predictions in a SQL database. Next time the company is queried the program can simply fetch the company from the database, rather than repeating the entire ML pipeline.
Models are automatically retrained at 11:50 PM (PST) every night.
ConsensusIO relies upon the free NewsAPI for its content. While powerful, this API is in no way finance-focused. Therefore, much of the news received is either not financial or not important. Due to the limiting nature of the free API, the platform only gathers news once per day per company. Ideally in the future, the platform will transition to the (paid) stocknewsapi.
Due to the free nature of the NewsAPI, the platform is limited to 500 articles a day. Therefore to ensure some form of usability, the article sets are limited per API call to a minimum of 10 per batch.
As of yet, ConsensusIO has no fancy solution to deal with concept drift. The new and old models are automatically tested on a preprocessed corpus of 100 entries. The new model is put into production only if it performs better (higher accuracy) on the verification corpus than the old model.
ConsensusIO was developed in summer 2019 by undergraduate David Gold. You can get in touch with him here:
LinkedIn
Email<EMAIL_ADDRESS>The source code for ConsensusIO is availible on GitHub. The ML notebooks responsible for the models are a mess, but also available in a separate repo.


Gundam Seed Destiny (GSD) is my favourite Gundam Anime when I was a child.

Friendship, Love, Wrath, Homeland.
All things are also influenced by war and will be described in this website.
Although Kira & Arthun are friends,
because of war, they need to fight with each other.
Although Shinn & Stella love each other,
because of war, they cannot have a good ending.
Although Kira was just wanted to stop the murder,
because he killed Stella in the war, Shinn takes revenge on him.
Although Cagali is weak,
even it is war, she also want to protect her country - Orb.
Friends
When I was child, I throught peoples' friends are also should be their comrades.
But when I was watching Gundam Seed Destiny, it has provided me a new perseption.
Our friends may not same as our comrades. But if my friend is my enemey, it is very cruel for ourseleves.
Kira and Arthun are friends. Different point of view on the war caused them fight with each other, even both are not wrong.
It is a cruel act to fight with friends in the battlefield.
Lovers
Ofcourse, when I was a kid, I didn't really understand what is love.
The person you want to play with? Maybe this was the anwser whild I was a child.
However, one thing I certainly remember which is Gundam Seed Destiny changed my love peception.
Since I was fantasizing if the lovers love each others, they must have a good ending when I was child.
Stella and Shinn. Although they love each other, they could not have a good ending.
Stella is dead. Although Shinn still alive, the sorrowful fact leads him plan to revenge.
Revenge
Shinn is extremly angery because of Stella death. Fortunately, there is a chance for him to revenge.
As Kira won't shoot mobile suit's cockpit, and Impulse Gundam can change the body parts while it is battling.
Finally Shinn defeated Kira.
When I was child, revenge this word is just for mischief.
But Shinn let me felt that revenge should be a behavior which is more important and serious.
I was really throught it is very cool when I was child.
Homeland
Which place should be counted as home? The house you live in? The district? Or the state?
Cagali has demonstrated the answer. She loves her state - Orb.
She want to protect her home country, even she is very weak, even her authority has lost.
I was impressed by Cagali's passion, speech, spirit and action when I was child,
especially while she takes akashuki to protect Orb.