| PostgreSQL 9.0.10 Documentation | ||||
|---|---|---|---|---|
| Prev | Up | Appendix E. Release Notes | Next |
Release date: 2002-02-04
This release improves PostgreSQL for use in high-volume applications.
Major changes in this release:
Vacuuming no longer locks tables, thus allowing normal user access during the vacuum. A new VACUUM FULL command does old-style vacuum by locking the table and shrinking the on-disk copy of the table.
There is no longer a problem with installations that exceed four billion transactions.
OIDs are now optional. Users can now create tables without OIDs for cases where OID usage is excessive.
The system now computes histogram column statistics during ANALYZE, allowing much better optimizer choices.
A new MD5 encryption option allows more secure storage and transfer of passwords. A new Unix-domain socket authentication option is available on Linux and BSD systems.
Administrators can use the new table access statistics module to get fine-grained information about table and index usage.
Program and library messages can now be displayed in several languages.
A dump/restore using pg_dump is required for those wishing to migrate data from any previous release.
Observe the following incompatibilities:
The semantics of the VACUUM command have changed in this release. You might wish to update your maintenance procedures accordingly.
In this release, comparisons using = NULL will always return false (or NULL, more precisely). Previous releases automatically transformed this syntax to IS NULL. The old behavior can be re-enabled using a postgresql.conf parameter.
The pg_hba.conf and pg_ident.conf configuration is now only reloaded after receiving a SIGHUP signal, not with each connection.
The function octet_length() now returns the uncompressed data length.
The date/time value 'current' is no longer available. You will need to rewrite your applications.
The timestamp(), time(), and interval() functions are no longer available. Instead of timestamp(), use timestamp 'string' or CAST.
The SELECT ... LIMIT #,# syntax will be removed in the next release. You should change your queries to use separate LIMIT and OFFSET clauses, e.g. LIMIT 10 OFFSET 20.
Create temporary files in a separate directory (Bruce)
Delete orphaned temporary files on postmaster startup (Bruce)
Added unique indexes to some system tables (Tom)
System table operator reorganization (Oleg Bartunov, Teodor Sigaev, Tom)
Renamed pg_log to pg_clog (Tom)
Enable SIGTERM, SIGQUIT to kill backends (Jan)
Removed compile-time limit on number of backends (Tom)
Better cleanup for semaphore resource failure (Tatsuo, Tom)
Allow safe transaction ID wraparound (Tom)
Removed OIDs from some system tables (Tom)
Removed "triggered data change violation" error check (Tom)
SPI portal creation of prepared/saved plans (Jan)
Allow SPI column functions to work for system columns (Tom)
Long value compression improvement (Tom)
Statistics collector for table, index access (Jan)
Truncate extra-long sequence names to a reasonable value (Tom)
Measure transaction times in milliseconds (Thomas)
Fix TID sequential scans (Hiroshi)
Superuser ID now fixed at 1 (Peter E)
New pg_ctl "reload" option (Tom)
Optimizer improvements (Tom)
New histogram column statistics for optimizer (Tom)
Reuse write-ahead log files rather than discarding them (Tom)
Cache improvements (Tom)
IS NULL, IS NOT NULL optimizer improvement (Tom)
Improve lock manager to reduce lock contention (Tom)
Keep relcache entries for index access support functions (Tom)
Allow better selectivity with NaN and infinities in NUMERIC (Tom)
R-tree performance improvements (Kenneth Been)
B-tree splits more efficient (Tom)
Change UPDATE, DELETE privileges to be distinct (Peter E)
New REFERENCES, TRIGGER privileges (Peter E)
Allow GRANT/REVOKE to/from more than one user at a time (Peter E)
New has_table_privilege() function (Joe Conway)
Allow non-superuser to vacuum database (Tom)
New SET SESSION AUTHORIZATION command (Peter E)
Fix bug in privilege modifications on newly created tables (Tom)
Disallow access to pg_statistic for non-superuser, add user-accessible views (Tom)
Fork postmaster before doing authentication to prevent hangs (Peter E)
Add ident authentication over Unix domain sockets on Linux, *BSD (Helge Bahmann, Oliver Elphick, Teodor Sigaev, Bruce)
Add a password authentication method that uses MD5 encryption (Bruce)
Allow encryption of stored passwords using MD5 (Bruce)
PAM authentication (Dominic J. Eidson)
Load pg_hba.conf and pg_ident.conf only on startup and SIGHUP (Bruce)
Interpretation of some time zone abbreviations as Australian rather than North American now settable at run time (Bruce)
New parameter to set default transaction isolation level (Peter E)
New parameter to enable conversion of "expr = NULL" into "expr IS NULL", off by default (Peter E)
New parameter to control memory usage by VACUUM (Tom)
New parameter to set client authentication timeout (Tom)
New parameter to set maximum number of open files (Tom)
Statements added by INSERT rules now execute after the INSERT (Jan)
Prevent unadorned relation names in target list (Bruce)
NULLs now sort after all normal values in ORDER BY (Tom)
New IS UNKNOWN, IS NOT UNKNOWN Boolean tests (Tom)
New SHARE UPDATE EXCLUSIVE lock mode (Tom)
New EXPLAIN ANALYZE command that shows run times and row counts (Martijn van Oosterhout)
Fix problem with LIMIT and subqueries (Tom)
Fix for LIMIT, DISTINCT ON pushed into subqueries (Tom)
Fix nested EXCEPT/INTERSECT (Tom)
Fix SERIAL in temporary tables (Bruce)
Allow temporary sequences (Bruce)
Sequences now use int8 internally (Tom)
New SERIAL8 creates int8 columns with sequences, default still SERIAL4 (Tom)
Make OIDs optional using WITHOUT OIDS (Tom)
Add %TYPE syntax to CREATE TYPE (Ian Lance Taylor)
Add ALTER TABLE / DROP CONSTRAINT for CHECK constraints (Christopher Kings-Lynne)
New CREATE OR REPLACE FUNCTION to alter existing function (preserving the function OID) (Gavin Sherry)
Add ALTER TABLE / ADD [ UNIQUE | PRIMARY ] (Christopher Kings-Lynne)
Allow column renaming in views
Make ALTER TABLE / RENAME COLUMN update column names of indexes (Brent Verner)
Fix for ALTER TABLE / ADD CONSTRAINT ... CHECK with inherited tables (Stephan Szabo)
ALTER TABLE RENAME update foreign-key trigger arguments correctly (Brent Verner)
DROP AGGREGATE and COMMENT ON AGGREGATE now accept an aggtype (Tom)
Add automatic return type data casting for SQL functions (Tom)
Allow GiST indexes to handle NULLs and multikey indexes (Oleg Bartunov, Teodor Sigaev, Tom)
Enable partial indexes (Martijn van Oosterhout)
Add RESET ALL, SHOW ALL (Marko Kreen)
CREATE/ALTER USER/GROUP now allow options in any order (Vince)
Add LOCK A, B, C functionality (Neil Padgett)
New ENCRYPTED/UNENCRYPTED option to CREATE/ALTER USER (Bruce)
New light-weight VACUUM does not lock table; old semantics are available as VACUUM FULL (Tom)
Disable COPY TO/FROM on views (Bruce)
COPY DELIMITERS string must be exactly one character (Tom)
VACUUM warning about index tuples fewer than heap now only appears when appropriate (Martijn van Oosterhout)
Fix privilege checks for CREATE INDEX (Tom)
Disallow inappropriate use of CREATE/DROP INDEX/TRIGGER/VIEW (Tom)
SUM(), AVG(), COUNT() now uses int8 internally for speed (Tom)
Add convert(), convert2() (Tatsuo)
New function bit_length() (Peter E)
Make the "n" in CHAR(n)/VARCHAR(n) represents letters, not bytes (Tatsuo)
CHAR(), VARCHAR() now reject strings that are too long (Peter E)
BIT VARYING now rejects bit strings that are too long (Peter E)
BIT now rejects bit strings that do not match declared size (Peter E)
INET, CIDR text conversion functions (Alex Pilosov)
INET, CIDR operators << and <<= indexable (Alex Pilosov)
Bytea \### now requires valid three digit octal number
Bytea comparison improvements, now supports =, <>, >, >=, <, and <=
Bytea now supports B-tree indexes
Bytea now supports LIKE, LIKE...ESCAPE, NOT LIKE, NOT LIKE...ESCAPE
Bytea now supports concatenation
New bytea functions: position, substring, trim, btrim, and length
New encode() function mode, "escaped", converts minimally escaped bytea to/from text
Add pg_database_encoding_max_length() (Tatsuo)
Add pg_client_encoding() function (Tatsuo)
now() returns time with millisecond precision (Thomas)
New TIMESTAMP WITHOUT TIMEZONE data type (Thomas)
Add ISO date/time specification with "T", yyyy-mm-ddThh:mm:ss (Thomas)
New xid/int comparison functions (Hiroshi)
Add precision to TIME, TIMESTAMP, and INTERVAL data types (Thomas)
Modify type coercion logic to attempt binary-compatible functions first (Tom)
New encode() function installed by default (Marko Kreen)
Improved to_*() conversion functions (Karel Zak)
Optimize LIKE/ILIKE when using single-byte encodings (Tatsuo)
New functions in contrib/pgcrypto: crypt(), hmac(), encrypt(), gen_salt() (Marko Kreen)
Correct description of translate() function (Bruce)
Add INTERVAL argument for SET TIME ZONE (Thomas)
Add INTERVAL YEAR TO MONTH (etc.) syntax (Thomas)
Optimize length functions when using single-byte encodings (Tatsuo)
Fix path_inter, path_distance, path_length, dist_ppath to handle closed paths (Curtis Barrett, Tom)
octet_length(text) now returns non-compressed length (Tatsuo, Bruce)
Handle "July" full name in date/time literals (Greg Sabino Mullane)
Some datatype() function calls now evaluated differently
Add support for Julian and ISO time specifications (Thomas)
National language support in psql, pg_dump, libpq, and server (Peter E)
Message translations in Chinese (simplified, traditional), Czech, French, German, Hungarian, Russian, Swedish (Peter E, Serguei A. Mokhov, Karel Zak, Weiping He, Zhenbang Wei, Kovacs Zoltan)
Make trim, ltrim, rtrim, btrim, lpad, rpad, translate multibyte aware (Tatsuo)
Add LATIN5,6,7,8,9,10 support (Tatsuo)
Add ISO 8859-5,6,7,8 support (Tatsuo)
Correct LATIN5 to mean ISO-8859-9, not ISO-8859-5 (Tatsuo)
Make mic2ascii() non-ASCII aware (Tatsuo)
Reject invalid multibyte character sequences (Tatsuo)
Now uses portals for SELECT loops, allowing huge result sets (Jan)
CURSOR and REFCURSOR support (Jan)
Can now return open cursors (Jan)
Add ELSEIF (Klaus Reger)
Improve PL/pgSQL error reporting, including location of error (Tom)
Allow IS or FOR key words in cursor declaration, for compatibility (Bruce)
Fix for SELECT ... FOR UPDATE (Tom)
Fix for PERFORM returning multiple rows (Tom)
Make PL/pgSQL use the server's type coercion code (Tom)
Memory leak fix (Jan, Tom)
Make trailing semicolon optional (Tom)
New untrusted PL/Perl (Alex Pilosov)
PL/Perl is now built on some platforms even if libperl is not shared (Peter E)
Now reports errorInfo (Vsevolod Lobko)
Add spi_lastoid function<EMAIL_ADDRESS>...is new (Andrew Bosma)
\d displays indexes in unique, primary groupings (Christopher Kings-Lynne)
Allow trailing semicolons in backslash commands (Greg Sabino Mullane)
Read password from /dev/tty if possible
Force new password prompt when changing user and database (Tatsuo, Tom)
Format the correct number of columns for Unicode (Patrice)
New function PQescapeString() to escape quotes in command strings (Florian Weimer)
New function PQescapeBytea() escapes binary strings for use as SQL string literals
Return OID of INSERT (Ken K)
Handle more data types (Ken K)
Handle single quotes and newlines in strings (Ken K)
Handle NULL variables (Ken K)
Fix for time zone handling (Barry Lind)
Improved Druid support
Allow eight-bit characters with non-multibyte server (Barry Lind)
Support BIT, BINARY types (Ned Wolpert)
Reduce memory usage (Michael Stephens, Dave Cramer)
Update DatabaseMetaData (Peter E)
Add DatabaseMetaData.getCatalogs() (Peter E)
Encoding fixes (Anders Bengtsson)
Get/setCatalog methods (Jason Davies)
DatabaseMetaData.getColumns() now returns column defaults (Jason Davies)
DatabaseMetaData.getColumns() performance improvement (Jeroen van Vianen)
Some JDBC1 and JDBC2 merging (Anders Bengtsson)
Transaction performance improvements (Barry Lind)
Array fixes (Greg Zoller)
Serialize addition
Fix batch processing (Rene Pijlman)
ExecSQL method reorganization (Anders Bengtsson)
GetColumn() fixes (Jeroen van Vianen)
Fix isWriteable() function (Rene Pijlman)
Improved passage of JDBC2 conformance tests (Rene Pijlman)
Add bytea type capability (Barry Lind)
Add isNullable() (Rene Pijlman)
JDBC date/time test suite fixes (Liam Stewart)
Fix for SELECT 'id' AS xxx FROM table (Dave Cramer)
Fix DatabaseMetaData to show precision properly (Mark Lillywhite)
New getImported/getExported keys (Jason Davies)
MD5 password encryption support (Jeremy Wohl)
Fix to actually use type cache (Ned Wolpert)
Remove query size limit (Hiroshi)
Remove text field size limit (Hiroshi)
Fix for SQLPrimaryKeys in multibyte mode (Hiroshi)
Allow ODBC procedure calls (Hiroshi)
Improve boolean handing (Aidan Mountford)
Most configuration options now settable via DSN (Hiroshi)
Multibyte, performance fixes (Hiroshi)
Allow driver to be used with iODBC or unixODBC (Peter E)
MD5 password encryption support (Bruce)
Add more compatibility functions to odbc.sql (Peter E)
EXECUTE ... INTO implemented (Christof Petig)
Multiple row descriptor support (e.g. CARDINALITY) (Christof Petig)
Fix for GRANT parameters (Lee Kindness)
Fix INITIALLY DEFERRED bug
Various bug fixes (Michael, Christof Petig)
Auto allocation for indicator variable arrays (int *ind_p=NULL)
Auto allocation for string arrays (char **foo_pp=NULL)
ECPGfree_auto_mem fixed
All function names with external linkage are now prefixed by ECPG
Fixes for arrays of structures (Michael)
Python fix fetchone() (Gerhard Haring)
Use UTF, Unicode in Tcl where appropriate (Vsevolod Lobko, Reinhard Max)
Add Tcl COPY TO/FROM (ljb)
Prevent output of default index op class in pg_dump (Tom)
Fix libpgeasy memory leak (Bruce)
Configure, dynamic loader, and shared library fixes (Peter E)
Fixes in QNX 4 port (Bernd Tegge)
Fixes in Cygwin and Windows ports (Jason Tishler, Gerhard Haring, Dmitry Yurtaev, Darko Prenosil, Mikhail Terekhov)
Fix for Windows socket communication failures (Magnus, Mikhail Terekhov)
Hurd compile fix (Oliver Elphick)
BeOS fixes (Cyril Velter)
Remove configure --enable-unicode-conversion, now enabled by multibyte (Tatsuo)
AIX fixes (Tatsuo, Andreas)
Fix parallel make (Peter E)
Install SQL language manual pages into OS-specific directories (Peter E)
Rename config.h to pg_config.h (Peter E)
Reorganize installation layout of header files (Peter E)
Remove SEP_CHAR (Bruce)
New GUC hooks (Tom)
Merge GUC and command line handling (Marko Kreen)
Remove EXTEND INDEX (Martijn van Oosterhout, Tom)
New pgjindent utility to indent java code (Bruce)
Remove define of true/false when compiling under C++ (Leandro Fanzone, Tom)
pgindent fixes (Bruce, Tom)
Replace strcasecmp() with strcmp() where appropriate (Peter E)
Dynahash portability improvements (Tom)
Add 'volatile' usage in spinlock structures
Improve signal handling logic (Tom)
New contrib/rtree_gist (Oleg Bartunov, Teodor Sigaev)
New contrib/tsearch full-text indexing (Oleg, Teodor Sigaev)
Add contrib/dblink for remote database access (Joe Conway)
contrib/ora2pg Oracle conversion utility (Gilles Darold)
contrib/xml XML conversion utility (John Gray)
contrib/fulltextindex fixes (Christopher Kings-Lynne)
New contrib/fuzzystrmatch with levenshtein and metaphone, soundex merged (Joe Conway)
Add contrib/intarray boolean queries, binary search, fixes (Oleg Bartunov)
New pg_upgrade utility (Bruce)
Add new pg_resetxlog options (Bruce, Tom)


College of Engineering and Information Sciences
Home
(current)
About
History
Faculty
Admission
Programs
Enrollment Requirements
Contacts
FAQ and Inquiries
×
SY 2018-2019 Curriculum
Information Technology
Computer Engineering
IT Specializations
Information Technology
Computer Engineering
Software Engineering
Mobile and Web Applications
Multimedia Arts & Animation
Data Science & Analytics
Enrollment Requirements
Admission Requirements
Application Form
For Freshmen
Entrance examination
One (1) ID picture (1×1, latest)
Form 138
Certificate of Good Moral Character
Birth Certificate from NSO (photocopy)
For Transferees
Entrance examination
One (1) ID picture (1×1, latest)
Honorable Dismissal
Scholastic Records / Copy of Grades
Certificate of Good Moral Character
Clearance for Admission from the Registrar’s Office
Freshmen
Transferees
Foreign Students


Merlise and Ed's Orchid Pages
Cattleya Alliance
Dendrobiums
Epidendrums
Oncidium Alliance
Phalenopsis
Phaphiopedilum and Phragmipedium
Vanda Alliance
Zygopetalum
Go to the
Triangle Orchid Society's Homepage
Back to
Merlise Clyde's Homepage


Uranus is the seventh planet from the Sun. It has the third-largest planetary radius and fourth-largest planetary mass in the Solar System. Uranus is similar in composition to Neptune, and both are of different chemical composition to the larger gas giants Jupiter and Saturn. Thus, astronomers sometimes place them in a separate category called "ice giants". Uranus's atmosphere, although similar to Jupiter's and Saturn's in its primary composition of hydrogen and helium, contains more "ices", such as water, ammonia, and methane, along with traces of hydrocarbons.
It is the coldest planetary atmosphere in the Solar System, with a minimum temperature of 49 K (-224.2 °C), and has a complex, layered cloud structure, with water thought to make up the lowest clouds, and methane the uppermost layer of clouds. In contrast, the interior of Uranus is mainly composed of ices and rock.


Secure Storage
There are two secure storage areas you may find useful.
Programmable Storage
This 128 KByte secure storage area can be modified. Performing an `erase all
in TinyCLR Config will wipe out this area.
Tip
Needed NuGets: GHIElectronics.TinyCLR.Core, GHIElectronics.TinyCLR.Devices.Storage, GHIElectronics.TinyCLR.Native
using GHIElectronics.TinyCLR.Devices.Storage;
using System;
using System.Diagnostics;
using System.Threading;
class Program {
private static void Main() {
const uint STORAGE_SIZE = 128 * 1024;
var data = new byte[STORAGE_SIZE];
var realStorageSize = Configuration.Size;
bool isErased = Configuration.IsErased(0, realStorageSize);
if (isErased == false) {
Debug.WriteLine("Configuration is not empty");
Debug.WriteLine("Erasing...");
bool erased = Configuration.Erase(0, realStorageSize);
Debug.WriteLine("Erased ? " + erased);
}
Debug.WriteLine("Fill buffer....");
for (var i = 0; i < data.Length; i++) {
data[i] = (byte)(i % 255);
}
Debug.WriteLine("Writing buffer....");
Configuration.Write(data, 0, 0, (uint)data.Length);
Debug.WriteLine("Clear buffer....");
Array.Clear(data, 0, data.Length);
Debug.WriteLine("Read configuration....");
Configuration.Read(data, 0, 0, realStorageSize);
Debug.WriteLine("Compare buffer....");
for (var i = 0; i < data.Length; i++) {
if (data[i] != (byte)(i % 255)) {
Debug.WriteLine("Configuration corrupted");
Thread.Sleep(-1);
}
}
Debug.WriteLine("The Configuration driver is good to go!!!!");
Thread.Sleep(-1);
}
}
One Time Programmable Area
The one time programmable (OTP) secure flash region is organized into 2048 blocks of 32 bytes each. Once you write to a block, that block can be read but never changed.
There is no way to modify written data. Erasing the entire device Erase All
in TinyCLR Config will not mot modify this area.
The static GHIElectronics.TinyCLR.Native.Flash class has methods to read and write OTP flash blocks and also to see if blocks are blank.
Writing an OTP Block
To write a block of 32 bytes to the OTP region of flash memory, use the following command:
GHIElectronics.TinyCLR.Native.Flash.OtpWrite(uint blockIndex, byte[] data);
The byte array of data must be exactly 32 bytes in length or an ArgumentOutOfRangeException
will be thrown.
Reading an OTP Block
To read a block from the OTP region of flash memory, use the following command:
GHIElectronics.TinyCLR.Native.Flash.OtpRead(uint blockIndex, byte[] data);
A byte array 32 bytes long will be returned.
Checking if an OTP Block is Blank
Note
If all 32 bytes of any OTP flash block contain 0xFF, the block is considered unused. If you write only 0xFF to the contents of a block, the block will be regarded as unused and you will be able to rewrite the block.
To see if a block is blank (all 32 bytes in block are 0xFF):
GHIElectronics.TinyCLR.Native.Flash.OtpIsBlank(uint blockIndex);
Returns a boolean value that is true if the block is blank.


Creates a new Writer
and initialises the
wrapped buffer to the default size of 8.
The wrapped buffer.
The current index of the buffer.
Ensures there is enough capacity in the current buffer to store addedBytes
more bytes.
The number of bytes which need to be added.
Writes a single byte to the buffer. Writes 1
if the value is true
and 0
otherwise.
The value to write.
Writes a 1 byte integer to the buffer.
The value to write.
Writes the length of the array as a 2 byte integer, then writes length
bytes to the buffer.
The value to write.
Writes a 4 byte floating point value to the buffer.
The value to write.
Writes a packet header to the first 5 bytes of this writer's buffer.
The id to write to the header.
Writes a 4 byte integer to the buffer.
The value to write.
Writes a 2 byte integer to the buffer.
The value to write.
Writes the length of the string as a 2 byte integer, then writes the string to the buffer.
The value to write.
The same as writeString()
, but writes 4 bytes for the length.
The value to write.
Writes a 4 byte unsigned integer to the buffer.
The value to write.
Writes a 1 byte unsigned integer to the buffer.
The value to write.
Writes a 2 byte unsigned integer to the buffer.
The value to write.
Generated using TypeDoc
A wrapper class which provides methods for writing data to a buffer.


"HEROD ARIPPA II". the son of Herod Agrippa I. and Cypros. The emperor Claudius made him tetrarch of the provinces of Philip and Lysanias, with the title of king (Acts 25:13; 26:2, 7). He enlarged the city of Caesarea Philippi, and called it Neronias, in honour of Nero. It was before him and his sister that Paul made his defence at Caesarea (Acts 25:12-27). He died at Rome A.D. 100, in the third year of the emperor Trajan.
"HEROD ARIPPA II". the son of Herod Agrippa I. and Cypros. The emperor Claudius made him tetrarch of the provinces of Philip and Lysanias, with the title of king (Acts 25:13; 26:2, 7). He enlarged the city of Caesarea Philippi, and called it Neronias, in honour of Nero. It was before him and his sister that Paul made his defence at Caesarea (Acts 25:12-27). He died at Rome A.D. 100, in the third year of the emperor Trajan.


0">
| Username | Mobile No. | Location | Current Due (BDT) | Previous Due (BDT) | Total Due (BDT) |
|---|---|---|---|---|---|
| {{ report.username }} | {{ report.mobile_no }} | {{ report.location }} | {{ report.current_due }} | {{ report.previous_due }} | {{ report.total_due }} |


configuration
Leave everything empty to apply the default settings.
Filters
The addon will apply the filters in the order your specify below. It's recommended to order the filters from highest to lowest quality.
Fetches streams from RARBG, 1337x, YTS and TPB+ addons, removes duplicates and sorts them by quality.
Leave everything empty to apply the default settings.
The addon will apply the filters in the order your specify below. It's recommended to order the filters from highest to lowest quality.


KDABRA, arose from the necessity to have a low-cost, all in one, integrated system to manage multimedia in Radio and/or television. Under this concept and making use of the latest tools that new technology has to offer, we've developed KDABRA as a new way of handling radio and television, providing simultaneous video, graphic, audio and mixing management.
Multiformat, play list fully automated reporters, schedule.
8 combination inputs, ptz camera, camera presets with audio follow,chromakey, tablet control, multiresolution
8 combination inputs, ptz camera, camera presets with audio follow,chromakey, tablet control, multiresolution, preview/program, DSKs, fade in/fade out – with or without template animation


subroutine mat_print_id(id,argcnt)
! ident_21="@(#)M_matrix::mat_print_id(3fp): print table of variable id names (up to) eight per line"
! ID Is array of GG_MAX_NAME_LENGTH character IDs to print
! ARGCNT is number of IDs to print
! If = -1, print one ID with an " =" suffix
!
integer :: id(GG_MAX_NAME_LENGTH,*)
integer :: argcnt
integer :: id_counter !
integer :: i, j, k
integer :: line_position ! pointer into output line being built
integer :: linebuf(8*GG_MAX_NAME_LENGTH+2*8+1) ! scratch buffer for building up line
character(len=(8*GG_MAX_NAME_LENGTH+2*8+1)) :: mline ! scratch space for building line to print
id_counter = 1 ! which ID to start the line with
INFINITE : do
linebuf(1)=blank ! put a space at beginning of line
line_position = 2
do j = id_counter,min(id_counter+7,iabs(argcnt)) ! copy up to eight names into buffer
do i = 1, GG_MAX_NAME_LENGTH ! copy one name into buffer
k = id(i,j) ! this is the kth letter of the set
linebuf(line_position) = k
if(linebuf(line_position).ne.blank)line_position = line_position+1 ! increment pointer into output
enddo
linebuf(line_position+0)=blank ! put two spaces between names
linebuf(line_position+1)=blank
line_position=line_position+2
enddo
if (argcnt .eq. -1) then ! special flag to print one word and =
linebuf(line_position) = equal ! put value for equal sign into buffer
else
line_position=line_position-3 ! was prepared for another ID with two blanks
endif
call mat_buf2str(mline,linebuf,line_position) ! write LINEBUF(1:line_position) line to a character variable
call journal(mline) ! print the line to stdout
id_counter = id_counter+8 ! prepare to get up to eight more IDs
if (id_counter .gt. iabs(argcnt)) exit INFINITE ! if not done do another line
enddo INFINITE
end subroutine mat_print_id


Robin Elahi, PhD |
|
PublicationsElahi CV |
Elahi, R., Dwyer, T.R. and K.P. Sebens. 2014. Mesoscale variability in oceanographic retention sets the abiotic stage for subtidal benthic diversity. Marine Ecology Progress Series: 498: 117-132 Elahi, R. and K.P. Sebens. 2013. Experimental removal and recovery of subtidal grazers highlights the importance of functional redundancy and temporal context. PLoS One: 8(11):e78969. doi:10.1371/journal.pone.0078969 Elahi, R., C. Birkeland, K.P. Sebens, K.R. Turner and T.R. Dwyer. 2013. Limited change in the diversity and structure of subtidal communites over four decades. Marine Biology 160: 3209-3219 Elahi, R. and K.P. Sebens. 2012. Consumers mediate natural variation between prey richness and resource use in a benthic marine community. Marine Ecology Progress Series 452: 131-143 Elahi, R. 2008. Effects of aggregation and species identity on the growth and behavior of mushroom corals. Coral Reefs 27: 881-885 Elahi, R. and P.J. Edmunds. 2007. Determinate growth and the scaling of photosynthetic energy intake in the solitary coral, Fungia concinna (Verrill). Journal of Experimental Marine Biology and Ecology 349:183-193 Elahi, R. and P.J. Edmunds. 2007. Tissue age affects calcification in the scleractinian coral, Madracis mirabilis. Biological Bulletin 212: 20-28 Elahi, R. and P.J. Edmunds. 2007. Consequences of fission in the coral Siderastrea siderea: growth rates of small colonies and clonal input to population structure. Coral Reefs 26:271-276 Edmunds, P.J. and R. Elahi. 2007. The demographics of a 15-year decline in cover of the Caribbean reef coral Montastraea annularis. Ecological Monographs 77: 3-18 |


In MathAce you train simple math - addition, subtraction, multiplication and division. You setup the characteristica of the quiz - if it should be timed, what kind of operations you'd like, sizes of the operands, size of the answer and if you'd like negative numbers to be in the quiz.
MathAce will then display a simple equation for you to solve. MathAce keeps tracks of your successes and failures. The Last 10 scores can be exported to Memo Pad.
Installation of MathAce is like installing any other Palm OS program:
When the synchronization is done you will have a 'MathAce' icon in the Unfiled category on your Palm PDA. Feel free to move MathAce to another category.
When starting MathAce you will be presented with a short menu. Select Preferences to set the characteristicas of the quiz. Select Beam Preferences to beam the preferences settings to another device. Select Show Scores to view the Last 10 Scores. Select Clear Scores to clear the Last 10 Scores list - you will be asked to confirm your action. Select Start Quiz to start the quiz.
The quiz is setup using the controls on the Preferences screen. First select the Quiz Type. You can choose between Calculate or Solve. In Calculate mode you always has so find the right hand side of the quiz - that is, the quizzes are on the form:
x + y = _ x - y = _ x * y = _ x / y = _
In Solve mode you will have to solve the equation. Depending on what you select in the Solve list you will get the following kind of quizzes:
x + _ = y _ - x = y x * y = _
If Solve is set to Left hand side only then only the first two kind of quizzes will be shown. If Solve is set to Both Sides then all kind of quizzes will be shown.
Select what kind of Scoring should be used. If you select First Guess then a point will only be scored if the first guess is correct. If Correct Guess is chosen, then a point will be scored whenever a correct answer is given. The former is more restrictive and was the default in MathAce up to version 1.5.
Select the size of the Max Operand or Max Answer. If the Max Operand is set to f.ex. 10 then the value to be guessed is no larger than 10 - other operands may be larger, though. So a quiz like 64 / 8 is valid. The Max Answer limits all the operands to be lower or equal to the threshold. So if Max Answer is set to f.ex. 10, then a quiz like 5 + 3 would be possible. The Max Answer only works for addition and subtraction quizzes.
The Min Operand value controls the lower bound of the quiz. If Min Operand is set to 2 and Max Operand is set to 10 then the quiz will be created using the numbers from 2 to 10.
Select the Operations to be chosen from. Also check the Allow Negative Numbers to enable signed quizzes (like in 5 * -3 and so forth).
Select if the quiz should be timed. A blank Timed field or a value of 0 disable the timer. Other values enable the timer for that many minutes.
When running the quiz you will get a display looking like a simple calculator. The buttons on the right, from top to bottom are: backspace, clear all, sign and OK (submit the answer). In the upper right corner you have a button to end the current quiz. In a timed game the time remaining will be shown between the 0 and OK buttons (not shown). When you press a button the time seems halt; but fear not - the timer is counted down in the background and as soon as you release the button the timer will catch up.
When the quiz is over you wil get a chance to enter your name for the Last 10 Scores list. Select Save Score to save the score. Select Don't Save Score to go to the main form without saving the score.
The Last 10 Scores list lists the last 10 scores (whoah!) The list is not to be taken as a High Score list. Tap an entry to view the details for that entry. Select Export to export the list to Memo Pad.
A detailed view of a randomly chosen entry. This view contains scores, rounds and the selected preferences for the quiz. This is more less how each entry in the Export list will look like.


Side: Right Left Bilateral
Number of views:
Bones:
Mineralization:
Joints:
Other findings:
Normal. No fracture or dislocation.


During our experiments I came upon a few TokuDB variables of interest; if you are using TokuDB you might want to look into these:
-
tokudb_analyze_time
This is a boundary on the number of seconds an ANALYZE TABLE will operate on each index on each partition on a TokuDB table.
That is, if tokudb_analyze_time = 5, and your table has 4 indexes (including PRIMARY) and 7 partitions, then the total runtime is limited to 5*4*7 = 140 seconds.
Default in 7.1.0: 5 seconds
-
tokudb_cache_size
Similar to innodb_buffer_pool_size, this variable sets the amount of memory allocated by TokuDB for caching pages. Like InnoDB the table is clustered within the index, so the cache includes pages for both indexes and data.
Default: 50% of total memory
-
tokudb_directio
Boolean, values are 0/1. Setting tokudb_directio = 1 is like specifying innodb_flush_method = O_DIRECT. Which in turn means the OS should not cache pages requested by TokuDB. Default: 0.
Now here's the interesting part: we are used to tell InnoDB to get the most memory we can provide (because we want it to cache as much as it can) and to avoid OS caching (because that would mean a page would appear both in the buffer pool and in OS memory, which is a waste). So the following setup is common:
innodb_buffer_pool_size = [as much as you can allocate while leaving room for connection memory]G innodb_flush_method = O_DIRECT
And my first instinct was to do the same for TokuDB. But after speaking to Gerry Narvaja of Tokutek, I realized it was not that simple. The reason TokuDB's default memory allocation is 50% and not, say, 90%, is that OS cache caches the data in compressed form, while TokuDB cache caches data in uncompressed form. Which means if you limit the TokuDB cache, you allow for more cache to the OS, that is used to cache compressed data, which means more data (hopefully, pending duplicates) in memory.
I did try both options and did not see an obvious difference, but did not test this thoroughly. My current setup is:
#No setup. just keep to the default for both: #tokudb_cache_size #tokudb_directio
-
tokudb_commit_sync
-
tokudb_fsync_log_period
These two variable are similar in essence to innodb_flush_log_at_trx_commit, but allow for finer tuning. With innodb_flush_log_at_trx_commit you choose between syncing the transaction log to disk upon each commit and once per second. With tokudb_commit_sync = 1 (which is default) you get transaction log sync to disk per commit. When tokudb_commit_sync = 0, then tokudb_fsync_log_period dictates the interval between flushes. So a value of tokudb_fsync_log_period = 1000 means once per second.
Since our original InnoDB installation used innodb_flush_log_at_trx_commit = 2, our TokuDB setup is:
tokudb_commit_sync = 0 tokudb_fsync_log_period = 1000
-
tokudb_load_save_space
Turned on (value 1) by default as of TokuDB 7.1.0, this parameter decides whether temporary file created on bulk load operations (e.g. ALTER TABLE) are compressed or uncompressed. Do yourself a big favour (why? read here) and keep it on. Our setup is:
tokudb_load_save_space = 1
TokuDB's general recommendation is: don't change the variables; the engine should work well right out of the box. I like the approach (by MySQL 5.5 I already lost count of InnoDB variables that can have noticeable impact; with 5.6 I'm all but lost). The complete list of configuration variables is found in TokuDB's Users Guide.
comments powered by Disqus


Unlocks an individual page in the form.
unlockPage(page, [speed])
| page |
number, zero indexed page number |
| speed |
int (optional), duration in millisecond |
Returns undefined.
Description
This method will unlock the form previously locked with lockPage() method. This method will call
w2utils.unlock() to perform the action.
If you have following form:
You can do:
Or:


Allopay lists your subscriptions and lets you pay your dues.
Be notified when we launch !
Allopay gives you the tools to measure, understand and control where your money goes. Looking at a monthly card statement is like looking at the cover of a book. It just says who got your money and how much. We go the extra mile and tell you how much you paid and for what. Allopay is designed around subscriptions and services, not just merchants.
Banks accounts, debit cards, credit cards, corporate cards, corporate accounts. We let you store all of them and use them as and when you want, wherever you want, for anything you want.
We were merchants once. We understand the difficulties in getting gateways. And integrating them to your systems. Redirecting to gateway pages, timed out transactions, refreshed pages. There are literlly a hundred different problems that could go wrong with your payments. We simplified all of this, with our proprietary asynchronous payment system. Simply tell us the mail id or mobile number of the user and the amount. We'll do the rest.
We don't have complex procedures to signup, joining fees or maintenence fees. We only charge a commision on transactions.
Our systems are RBI compliant and hence can process recurring payments without hassle. We even support intangible goods.
We use a RESTful API to make transactions truly Asynchronus, Making Allopay literally impervious to all transaction faliures that plague other gateways.
Register your email now to be notified when we launch !


Please help us on Product Hunt and Designer News. Thanks in advance!
Curious why I decided to create CoreUI? Please read this article: Jack of all trades, master of none. Why Bootstrap Admin Templates suck.
CoreUI is an Open Source Bootstrap Admin Template. But CoreUI is not just another Admin Template. It goes way beyond hitherto admin templates thanks to transparent code and file structure. And if that's not enough, let’s just add that CoreUI consists bunch of unique features and over 1000 high quality icons.
CoreUI is based on Bootstrap 4 and offers 6 versions: HTML5 AJAX, HTML5, Angular 2+, React.js & Vue.js, .NET Core 2.
CoreUI is meant to be the UX game changer. Pure & transparent code is devoid of redundant components, so the app is light enough to offer ultimate user experience. This means mobile devices also, where the navigation is just as easy and intuitive as on a desktop or laptop. The CoreUI Layout API lets you customize your project for almost any device – be it Mobile, Web or WebApp – CoreUI covers them all!
CoreUI is built on top of Bootstrap 4 and supports popular frameworks.
| CoreUI Pro | Prime | Root | Alba | Leaf |
|---|---|---|---|---|
# clone the repo
$ git clone https://github.com/coreui/coreui-free-angular-admin-template.git my-project
# go into app's directory
$ cd my-project
# install app's dependencies
$ npm install
# serve with hot reload at localhost:4200.
$ ng serve
# build for production with minification
$ ng build
Within the download you'll find the following directories and files, logically grouping common assets and providing both compiled and minified variations. You'll see something like this:
free-angular-admin-template/
├── e2e/
├── src/
│ ├── app/
│ ├── assets/
│ ├── environments/
│ ├── scss/
│ ├── index.html
│ └── ...
├── .angular-cli.json
├── ...
├── package.json
└── ...
The documentation for the CoreUI Free Angularp Admin Template is hosted at our website CoreUI
Please read through our contributing guidelines. Included are directions for opening issues, coding standards, and notes on development.
Editor preferences are available in the editor config for easy use in common text editors. Read more and download plugins at http://editorconfig.org.
For transparency into our release cycle and in striving to maintain backward compatibility,CoreUI Free Admin Template is maintained under the Semantic Versioning guidelines.
See the Releases section of our project for changelogs for each release version.
Łukasz Holeczek
Andrzej Kopański
Get updates on CoreUI's development and chat with the project maintainers and community members.
Some of projects created by community but not maintained by CoreUI team.
copyright 2018 creativeLabs Łukasz Holeczek. Code released under the MIT license. There is only one limitation you can't re-distribute the CoreUI as stock. You can’t do this if you modify the CoreUI. In past we faced some problems with persons who tried to sell CoreUI based templates.
CoreUI is an MIT licensed open source project and completely free to use. However, the amount of effort needed to maintain and develop new features for the project is not sustainable without proper financial backing. You can support development by donating on PayPal, buying CoreUI Pro Version or buying one of our premium admin templates.
As of now I am exploring the possibility of working on CoreUI fulltime - if you are a business that is building core products using CoreUI, I am also open to conversations regarding custom sponsorship / consulting arrangements. Get in touch on Twitter.


Responsive website developing is my game. I love building creative, engaging websites that work across all digital media. My expertise is in crafting visual stories for your business, aligning your visual aesthetic across all social media platforms, and designing beautiful, user-friendly websites.
Bio: Born, bred, and based 15 minutes from Los Angeles. I've always been drawn to art and design and have a long history in fashion design, art education, and currently moonlight as a surface pattern designer.
Current Passions: I absolutely love to travel, read fiction, and experiment in the kitchen. My cookbook collection rivals my design book library in size.


Preparation time
less than 30 mins
Cooking time
10 to 30 mins
Serves
Serves 4
For the parmesan-crusted halibut, in a bowl, mix together the parmesan, curry powder, garam masala, turmeric and salt until well combined.
Dredge one side of each cube of halibut in the parmesan mixture until thickly coated.
Heat a heavy, non-stick frying pan over a low to medium heat. When the pan is warm, add the halibut cubes, parmesan-coated sides down, and dry fry for 4-5 minutes, or until the parmesan crusts are crisp and golden-brown.
Season the halibut cubes, to taste, with salt, then turn them over and remove the pan from the heat. (NB: The residual heat from the pan will cook the other sides of the halibut cubes.)
For the lime emulsion, immediately add all of the lime emulsion ingredients to the pan containing the halibut cubes and set aside for 2-3 minutes.
Meanwhile, for the sag aloo, heat the oil in a large frying pan over a high heat. Add the shallot and garlic and cook for 2-3 minutes, or until softened.
Add the spices and continue to fry for 1-2 minutes, or until fragrant.
Add the cooked new potatoes and continue to cook for a further minute, or until warmed through.
Remove the pan from the heat and add the baby spinach. Stir well until the spinach has wilted, then season, to taste, with salt.
To serve, divide the sag aloo equally among each of four serving plates. Place four cubes of parmesan-crusted halibut on top of each portion of sag aloo. Transfer the lime emulsion mixture from the pan to a bowl and whisk until well combined, then drizzle it over the halibut cubes and around the edge of the plates. Garnish with the coriander cress.


Leanne Chin
About
Portfolio
Contact
Portfolio Pieces
UX/UI Design
Illustrator
Portrait Photography
Sport Photography


Sometimes you have to put Google through its paces. After selecting today's quotation (originally published in 1893, by the way) I decided to look up “bad drawing of a horse”. This yielded two—identical—results, the transcript of a 1982 interview with Andy Partridge, in which he referred to certain record company executives' reactions to the image used for the cover of XTC's English Settlement album:
Mildly disappointed at the paucity of results, I tried again with “bad drawing”+“horse” as my search parameters. This time I got 197 results. A disturbing amount led me to sci-fi and fantasy art fandom sites. Don't even go there. When I had recovered from the resultant headache, and pondered the number of centaurs and unicorns I had stumbled upon, I ploughed on. All I wanted was something to illustrate the quotation, and eventually I found it. Alright, I know it's a child's drawing rather than a bad drawing per se, but, you know, here at Hooting Yard we go to great lengths to entertain and instruct our readers, and we still miss the guiding hand of Mrs Gubbins, whose latest exploits were recorded the day before yesterday.


|
teos library
0.8
EOSIO smart contract IDE library
|
Classes | |
| class | teos::command::CreateAccount |
| Create an account, buy ram, stake for bandwidth for the account. More... | |
| class | teos::command::CreateKey |
| Create a new keypair and print the public and private keys. More... | |
| class | teos::command::GetInfo |
| Get current blockchain information. More... | |
| class | teos::command::GetBlock |
| Retrieve a full block from a blockchain. More... | |
| class | teos::command::GetAccount |
| Fetch a blockchain account. More... | |
| class | teos::command::GetAccounts |
| Retrieve accounts associated with a public key. More... | |
| class | teos::command::GetCode |
| Retrieves the code and ABI for an account. More... | |
| class | teos::command::GetTable |
| Retrieves the contents of a database table. More... | |
| class | teos::command::VersionClient |
| Retrieve version information of the client. More... | |
| class | teos::command::PushAction |
| Push a transaction with a single message. More... | |
| class | teos::command::SetContract |
| Create or update the contract on an account. More... | |
| class | teos::command::WalletCreate |
| Create a new wallet locall. More... | |
| class | teos::command::WalletImport |
| Import private key into wallet. More... | |
| class | teos::command::WalletList |
| List opened wallets, * = unlocked. More... | |
| class | teos::command::WalletOpen |
| Open an existing wallet. More... | |
| class | teos::command::WalletLock |
| Lock wallet. More... | |
| class | teos::command::WalletLockAll |
| Lock all unlocked wallets. More... | |
| class | teos::command::WalletUnlock |
| Unlock wallet. More... | |
| class | teos::control::BuildContract |
| Build a contract: produce the WAST file for the contract. More... | |
| class | teos::control::GenerateAbi |
| class | teos::control::BootstrapContract |
| BootstrapContract: produce contract workspace from a given template. More... | |
| class | teos::control::DeleteContract |
| class | teos::control::GetConfig |
| Returns the configuration of the runtime. More... | |
| class | teos::control::DaemonStop |
| Kill the running local NODEOS process. More... | |
| class | teos::control::DaemonStart |
| Start a local NODEOS node, if no one is running. More... | |


Demonstrates how the messageService API can be used by a module to receive data sent from another module.
Message Received:


Amount represents a positive quantity of some token (currency, asset, etc.), measured in quantity of the smallest
representable units. The nominal quantity represented by each individual token is equal to the displayTokenSize.
The scale property of the displayTokenSize should correctly reflect the displayed decimal places and is used
when rounding conversions from indicative/displayed amounts in BigDecimal to Amount occur via the
Amount.fromDecimal method.
This class represents a possibly negative transfer of tokens from one vault state to another, possibly at a future date.
An attachment is a ZIP (or an optionally signed JAR) that contains one or more files. Attachments are meant to
contain public static data which can be referenced from transactions and utilised from contracts. Good examples
of how attachments are meant to be used include:
The node asked a remote peer for the attachment identified by hash because it is a dependency of a transaction
being resolved, but the remote peer would not provide it.
An attachment store records potentially large binary objects, identified by their hash.
An abstract class defining fields shared by all transaction types in the system.
This annotation is required by any ContractState which needs to ensure that it is only ever processed as part of a
TransactionState referencing the specified Contract. It may be omitted in the case that the ContractState class
is defined as an inner class of its owning Contract class, in which case the "X belongs to Y" relationship is taken
to be implicitly declared.
A non-specific exception for the attachment identified by attachmentId. The context
for this error is provided via the message and cause.
(extensions in package net.corda.v5.ledger.contracts)
Command data/content plus pubkey pair: the signature is stored at the end of the serialized bytes
Return structure for OwnableState.withNewOwner
Marker interface for classes that represent commands
A ComponentGroup is used to store the full list of transaction components of the same type in serialised form.
Practically, a group per component type of a transaction is required; thus, there will be a group for input states,
a group for all attachments (if there are any) etc.
An enum, for which each property corresponds to a transaction component group. The position in the enum class
declaration (ordinal) is used for component-leaf ordering when computing the Merkle tree.
Thrown when checking for visibility of all-components in a group in FilteredTransaction.checkAllComponentsVisible.
Implemented by a program that implements business logic on the shared ledger. All participants run this code for
every net.corda.core.transactions.LedgerTransaction they see on the network, for every input and output state. All
contracts must accept the transaction for it to be accepted: failure of any aborts the entire thing. The time is taken
from a trusted time-window attached to the transaction itself i.e. it is NOT necessarily the current time.
A contract state (or just "state") contains opaque data used by a contract program. It can be thought of as a disk
file that the program can use to persist data across transactions. States are immutable: once created they are never
updated, instead, any changes must generate a new successor state. States can be updated (consumed) only once: the
notary is responsible for ensuring there is no "double spending" by only signing a transaction if the input states
are all free.
A transaction with the minimal amount of information required to compute the unique transaction id, and
resolve a FullTransaction. This type of transaction, wrapped in SignedTransaction, gets transferred across the
wire and recorded to storage.
Constrain which contract-code-containing CPK can be used with a Contract.
The necessary context to determine whether a CPKConstraint is satisfied.
Marker interface to denote a persistable Corda state entity that exposes the transaction id and index as composite key called stateRef.
Thrown to indicate that an attachment was already uploaded to a Corda node.
Contains information about a field from an entity class.
Used as part of query criteria construction through Builder, produced by function getField.
The constructor should not be invoked manually.
A FilteredComponentGroup is used to store the filtered list of transaction components of the same type in serialised form.
This is similar to ComponentGroup, but it also includes the corresponding nonce per component.
Class representing merkleized filtered transaction.
Thrown when FilteredTransaction.verify fails.
A transaction with fully resolved components, such as input states.
Interface to represent things which are fungible, this means that there is an expectation that these things can
be split and merged. That's the only assumption made by this interface.
Identity function post-processor that returns ContractStates with no side-effects.
Simple post-processor that just returns StateAndRefs with no side-effects.
Marker interface to denote a persistable Corda state entity that exposes the transaction id and index as a nested composite key called compositeKey
that is itself a DirectStatePersistable. i.e. exposes a stateRef.
The Issued data class holds the details of an on ledger digital asset.
In particular it gives the public credentials of the entity that created these digital tokens
and the particular product represented.
(extensions in package net.corda.v5.ledger.contracts)
A LedgerTransaction is derived from a WireTransaction. It is the result of doing the following operations:
The annotated Contract implements the legal prose identified by the given URI.
LinearPointer allows a ContractState to "point" to another LinearState creating a "many-to-one" relationship
between all the states containing the pointer to a particular LinearState and the LinearState being pointed to.
Using the LinearPointer is useful when one state depends on the data contained within another state that evolves
independently. When using LinearPointer it is worth noting:
A state that evolves by superseding itself, all of which share the common "linearId".
(extensions in package net.corda.v5.ledger)
Thrown during deserialization to indicate that an attachment needed to construct the WireTransaction is not found.
A common move command for contract states which can change owner.
(extensions in package net.corda.v5.ledger)
Wrapper over SecureHash to be used when filtering network parameters hash.
A notary change transaction with fully resolved inputs and signatures. In contrast with a regular transaction,
signatures are checked against the signers specified by input states' participants fields, so full resolution is
needed for signature verification.
A special transaction for changing the notary of a state. It only needs specifying the state(s) as input(s),
old and new notaries. Output states can be computed by applying the notary modification to corresponding inputs
on the fly.
Specifies the cause for notarisation request failure.
Exception thrown by the notary service if any issues are encountered while trying to commit a transaction. The
underlying error specifies the cause of failure.
Stores information about notaries available in the network.
Lookup of notary services and their types on the network.
A contract state that can have a single owner.
PageSpecification allows specification of a page number (starting from DEFAULT_PAGE_NUM) and page size
(defaulting to DEFAULT_PAGE_SIZE with a maximum page size of MAX_PAGE_SIZE)
Note: we default the page number to DEFAULT_PAGE_SIZE to enable queries without requiring a page specification
but enabling detection of large results sets that fall out of the DEFAULT_PAGE_SIZE requirement.
MAX_PAGE_SIZE should be used with extreme caution as results may exceed your JVM memory footprint.
A super class for all mapped states exported to a schema that ensures the StateRef appears on the database row. The
StateRef will be set to the correct value by the framework (there's no need to set during mapping generation by the state itself).
Embedded StateRef representation used in state mapping.
A privacy salt is required to compute nonces per transaction component in order to ensure that an adversary cannot
use brute force techniques and reveal the content of a Merkle-leaf hashed value.
Because this salt serves the role of the seed to compute nonces, its size and entropy should be equal to the
underlying hash function used for Merkle tree generation, currently SecureHash.SHA256, which has an output of 32 bytes.
There are two constructors, one that generates a new 32-bytes random salt, and another that takes a ByteArray input.
The latter is required in cases where the salt value needs to be pre-generated (agreed between transacting parties),
but it is highlighted that one should always ensure it has sufficient entropy.
A contract state that may be mapped to database schemas configured for this node to support querying for,
or filtering of, states.
A wrapper for a StateAndRef indicating that it should be added to a transaction as a reference input state.
Wrapper over StateRef to be used when filtering reference states.
If the querying node is a participant in a state then it is classed as RELEVANT.
Defines a simple domain specific language for the specification of financial contracts. Currently covers:
Constrains which CPK can be used with a contract using the hashes of the public keys that signed the CPK.
SignedTransaction wraps a serialized WireTransaction. It contains one or more signatures, each one for
a public key (including composite keys) that is mentioned inside a transaction command. SignedTransaction is the top level transaction type
and the type most frequently passed around the network and stored. The identity of a transaction is the hash of Merkle root
of a WireTransaction, therefore if you are storing data keyed by WT hash be aware that multiple different STs may
map to the same key (and they could be different in important ways, like validity!). The signatures on a
SignedTransaction might be invalid or missing: the type does not imply validity.
A transaction ID should be the hash of the WireTransaction Merkle tree root. Thus adding or removing a signature does not change it.
Extract of data from SignedTransaction, primarily to be sensibly represented in JSON
Also useful on the client side to inspect what was actually returned as result of the flow
Sort allows specification of a set of entity attribute names and their associated directionality
and null handling, to be applied upon processing a query specification.
Simple data class to associate the origin, owner, or holder of a particular Amount object.
A convenience class for passing around a state and it's contract
A StateAndRef is simply a (state, ref) pair. For instance, a vault (which holds available assets) contains these.
Post-processors can be implemented to enhance the Named Query API.
Contains information about the consuming transaction for a particular state.
Marker interface to denote a persistable Corda state entity that will always have a transaction id and index
A StatePointer contains a pointer to a ContractState. The StatePointer can be included in a ContractState
or included in an off-ledger data structure. StatePointers can be resolved to a StateAndRef by performing a
vault query. There are two types of pointers; linear and static. LinearPointers are for use with LinearStates.
StaticPointers are for use with any type of ContractState.
A stateref is a pointer (reference) to a state, this is an equivalent of an "outpoint" in Bitcoin. It records which
transaction defined the state and where in that transaction it was.
Controls whether the transaction is sent to the vault at all, and if so whether states have to be relevant
or not in order to be recorded. Used in TransactionService.record
A StaticPointer contains a pointer to a specific StateRef and can be resolved by looking up the StateRef via
StateLoaderService. There are a number of things to keep in mind when using StaticPointers:
An interval on the time-line; not a single instantaneous point.
This interface is used by Amount to determine the conversion ratio from
indicative/displayed asset amounts in BigDecimal to fungible tokens represented by Amount objects.
A TransactionBuilder is a transaction class that's mutable (unlike the others which are all immutable). It is
intended to be passed around contracts that may edit it by adding new states/commands. Then once the states
and commands are right, this class can be used as a holding bucket to gather signatures from multiple parties.
A class that holds a map of digest services used for hashing transaction components and
label the transaction's Merkle tree leaves and nodes.
The node asked a remote peer for the transaction identified by hash because it is a dependency of a transaction
being resolved, but the remote peer would not provide it.
A wrapper for ContractState containing additional platform-level state information and contract information. This is the definitive
state that is stored on the ledger and used in transaction outputs.
Indicates that some aspect of the transaction named by txId violates the platform rules. The exact type of failure
is expressed using a subclass. TransactionVerificationException is a FlowException and thus when thrown inside
a flow, the details of the failure will be serialised, propagated to the peer and rethrown.
Provides a transaction verification service.
An interface for transactions containing signatures, with logic for signature verification.
Implemented by WireTransaction and FilteredTransaction. A TraversableTransaction allows you to iterate
over the flattened components of the underlying transaction structure, taking into account that some
may be missing in the case of this representing a "torn" transaction. Please see the user guide section
"Transaction tear-offs" to learn more about this feature.
Commands that inherit from this are intended to have no data items: it's only their presence that matters.
This class provides a truly unique identifier of a trade, state, or other business object, bound to any existing
external ID. Equality and comparison are based on the unique ID only; if two states somehow have the same UUID but
different external IDs, it would indicate a problem with handling of IDs.
JPA representation of the core Vault Schema
First version of the Vault ORM schema
VaultStateEvent contains information about state changes to the vault.
VaultStateEventService allows CordaServices to subscribe to vault state events triggered by the recording of ContractStates to the
vault.
Contract version and flow versions are integers.
A transaction ready for serialisation, without any signatures attached. A WireTransaction is usually wrapped
by a SignedTransaction that carries the signatures over this payload.
The identity of the transaction is the Merkle tree root of its components (see MerkleTree).


Hobbies: eating,talking,dancing
Hobbies: eating,talking,dancing
Hobbies: eating,talking,dancing
Hobbies: eating,talking,dancing
Hobbies: eating,talking,dancing
Hobbies: eating,talking,dancing
Hobbies: eating,talking,dancing
Hobbies: eating,talking,dancing
Hobbies: eating,talking,dancing
©Yearbook.co 2018


Introducing Stream Windows in Apache Flink
December 4, 2015 -The data analysis space is witnessing an evolution from batch to stream processing for many use cases. Although batch can be handled as a special case of stream processing, analyzing never-ending streaming data often requires a shift in the mindset and comes with its own terminology (for example, “windowing” and “at-least-once”/”exactly-once” processing). This shift and the new terminology can be quite confusing for people being new to the space of stream processing. Apache Flink is a production-ready stream processor with an easy-to-use yet very expressive API to define advanced stream analysis programs. Flink’s API features very flexible window definitions on data streams which let it stand out among other open source stream processors.
In this blog post, we discuss the concept of windows for stream processing, present Flink’s built-in windows, and explain its support for custom windowing semantics.
What are windows and what are they good for? #
Consider the example of a traffic sensor that counts every 15 seconds the number of vehicles passing a certain location. The resulting stream could look like:
If you would like to know, how many vehicles passed that location, you would simply sum the individual counts. However, the nature of a sensor stream is that it continuously produces data. Such a stream never ends and it is not possible to compute a final sum that can be returned. Instead, it is possible to compute rolling sums, i.e., return for each input event an updated sum record. This would yield a new stream of partial sums.
However, a stream of partial sums might not be what we are looking for, because it constantly updates the count and even more important, some information such as variation over time is lost. Hence, we might want to rephrase our question and ask for the number of cars that pass the location every minute. This requires us to group the elements of the stream into finite sets, each set corresponding to sixty seconds. This operation is called a tumbling windows operation.
Tumbling windows discretize a stream into non-overlapping windows. For certain applications it is important that windows are not disjunct because an application might require smoothed aggregates. For example, we can compute every thirty seconds the number of cars passed in the last minute. Such windows are called sliding windows.
Defining windows on a data stream as discussed before is a non-parallel operation. This is because each element of a stream must be processed by the same window operator that decides which windows the element should be added to. Windows on a full stream are called AllWindows in Flink. For many applications, a data stream needs to be grouped into multiple logical streams on each of which a window operator can be applied. Think for example about a stream of vehicle counts from multiple traffic sensors (instead of only one sensor as in our previous example), where each sensor monitors a different location. By grouping the stream by sensor id, we can compute windowed traffic statistics for each location in parallel. In Flink, we call such partitioned windows simply Windows, as they are the common case for distributed streams. The following figure shows tumbling windows that collect two elements over a stream of (sensorId, count)
pair elements.
Generally speaking, a window defines a finite set of elements on an unbounded stream. This set can be based on time (as in our previous examples), element counts, a combination of counts and time, or some custom logic to assign elements to windows. Flink’s DataStream API provides concise operators for the most common window operations as well as a generic windowing mechanism that allows users to define very custom windowing logic. In the following we present Flink’s time and count windows before discussing its windowing mechanism in detail.
Time Windows #
As their name suggests, time windows group stream elements by time. For example, a tumbling time window of one minute collects elements for one minute and applies a function on all elements in the window after one minute passed.
Defining tumbling and sliding time windows in Apache Flink is very easy:
// Stream of (sensorId, carCnt)
val vehicleCnts: DataStream[(Int, Int)] = ...
val tumblingCnts: DataStream[(Int, Int)] = vehicleCnts
// key stream by sensorId
.keyBy(0)
// tumbling time window of 1 minute length
.timeWindow(Time.minutes(1))
// compute sum over carCnt
.sum(1)
val slidingCnts: DataStream[(Int, Int)] = vehicleCnts
.keyBy(0)
// sliding time window of 1 minute length and 30 secs trigger interval
.timeWindow(Time.minutes(1), Time.seconds(30))
.sum(1)
There is one aspect that we haven’t discussed yet, namely the exact meaning of “collects elements for one minute” which boils down to the question, “How does the stream processor interpret time?”.
Apache Flink features three different notions of time, namely processing time, event time, and ingestion time.
- In processing time, windows are defined with respect to the wall clock of the machine that builds and processes a window, i.e., a one minute processing time window collects elements for exactly one minute.
- In event time, windows are defined with respect to timestamps that are attached to each event record. This is common for many types of events, such as log entries, sensor data, etc, where the timestamp usually represents the time at which the event occurred. Event time has several benefits over processing time. First of all, it decouples the program semantics from the actual serving speed of the source and the processing performance of system. Hence you can process historic data, which is served at maximum speed, and continuously produced data with the same program. It also prevents semantically incorrect results in case of backpressure or delays due to failure recovery. Second, event time windows compute correct results, even if events arrive out-of-order of their timestamp which is common if a data stream gathers events from distributed sources.
- Ingestion time is a hybrid of processing and event time. It assigns wall clock timestamps to records as soon as they arrive in the system (at the source) and continues processing with event time semantics based on the attached timestamps.
Count Windows #
Apache Flink also features count windows. A tumbling count window of 100 will collect 100 events in a window and evaluate the window when the 100th element has been added.
In Flink’s DataStream API, tumbling and sliding count windows are defined as follows:
// Stream of (sensorId, carCnt)
val vehicleCnts: DataStream[(Int, Int)] = ...
val tumblingCnts: DataStream[(Int, Int)] = vehicleCnts
// key stream by sensorId
.keyBy(0)
// tumbling count window of 100 elements size
.countWindow(100)
// compute the carCnt sum
.sum(1)
val slidingCnts: DataStream[(Int, Int)] = vehicleCnts
.keyBy(0)
// sliding count window of 100 elements size and 10 elements trigger interval
.countWindow(100, 10)
.sum(1)
Dissecting Flink’s windowing mechanics #
Flink’s built-in time and count windows cover a wide range of common window use cases. However, there are of course applications that require custom windowing logic that cannot be addressed by Flink’s built-in windows. In order to support also applications that need very specific windowing semantics, the DataStream API exposes interfaces for the internals of its windowing mechanics. These interfaces give very fine-grained control about the way that windows are built and evaluated.
The following figure depicts Flink’s windowing mechanism and introduces the components being involved.
Elements that arrive at a window operator are handed to a WindowAssigner
. The WindowAssigner assigns elements to one or more windows, possibly creating new windows. A Window
itself is just an identifier for a list of elements and may provide some optional meta information, such as begin and end time in case of a TimeWindow
. Note that an element can be added to multiple windows, which also means that multiple windows can exist at the same time.
Each window owns a Trigger
that decides when the window is evaluated or purged. The trigger is called for each element that is inserted into the window and when a previously registered timer times out. On each event, a trigger can decide to fire (i.e., evaluate), purge (remove the window and discard its content), or fire and then purge the window. A trigger that just fires evaluates the window and keeps it as it is, i.e., all elements remain in the window and are evaluated again when the triggers fires the next time. A window can be evaluated several times and exists until it is purged. Note that a window consumes memory until it is purged.
When a Trigger fires, the list of window elements can be given to an optional Evictor
. The evictor can iterate through the list and decide to cut off some elements from the start of the list, i.e., remove some of the elements that entered the window first. The remaining elements are given to an evaluation function. If no Evictor was defined, the Trigger hands all the window elements directly to the evaluation function.
The evaluation function receives the elements of a window (possibly filtered by an Evictor) and computes one or more result elements for the window. The DataStream API accepts different types of evaluation functions, including predefined aggregation functions such as sum()
, min()
, max()
, as well as a ReduceFunction
, FoldFunction
, or WindowFunction
. A WindowFunction is the most generic evaluation function and receives the window object (i.e, the metadata of the window), the list of window elements, and the window key (in case of a keyed window) as parameters.
These are the components that constitute Flink’s windowing mechanics. We now show step-by-step how to implement custom windowing logic with the DataStream API. We start with a stream of type DataStream[IN]
and key it using a key selector function that extracts a key of type KEY
to obtain a KeyedStream[IN, KEY]
.
val input: DataStream[IN] = ...
// created a keyed stream using a key selector function
val keyed: KeyedStream[IN, KEY] = input
.keyBy(myKeySel: (IN) => KEY)
We apply a WindowAssigner[IN, WINDOW]
that creates windows of type WINDOW
resulting in a WindowedStream[IN, KEY, WINDOW]
. In addition, a WindowAssigner
also provides a default Trigger
implementation.
// create windowed stream using a WindowAssigner
var windowed: WindowedStream[IN, KEY, WINDOW] = keyed
.window(myAssigner: WindowAssigner[IN, WINDOW])
We can explicitly specify a Trigger
to overwrite the default Trigger
provided by the WindowAssigner
. Note that specifying a triggers does not add an additional trigger condition but replaces the current trigger.
// override the default trigger of the WindowAssigner
windowed = windowed
.trigger(myTrigger: Trigger[IN, WINDOW])
We may want to specify an optional Evictor
as follows.
// specify an optional evictor
windowed = windowed
.evictor(myEvictor: Evictor[IN, WINDOW])
Finally, we apply a WindowFunction
that returns elements of type OUT
to obtain a DataStream[OUT]
.
// apply window function to windowed stream
val output: DataStream[OUT] = windowed
.apply(myWinFunc: WindowFunction[IN, OUT, KEY, WINDOW])
With Flink’s internal windowing mechanics and its exposure through the DataStream API it is possible to implement very custom windowing logic such as session windows or windows that emit early results if the values exceed a certain threshold.
Conclusion #
Support for various types of windows over continuous data streams is a must-have for modern stream processors. Apache Flink is a stream processor with a very strong feature set, including a very flexible mechanism to build and evaluate windows over continuous data streams. Flink provides pre-defined window operators for common uses cases as well as a toolbox that allows to define very custom windowing logic. The Flink community will add more pre-defined window operators as we learn the requirements from our users.


--- layout: default permalink: /projects/ ---
This semester we are collaborating with the Rensselaer Polytechnic Institute near Albany, New York. We are bringing one of their open source projects called YACS (Yet Another Course Scheduler) to NYU. Currently the NYU team is working on converting the Albert data to “YACS form”. Along with that there is work to be done on frontend and backend so YACS can be adopted for NYU. The team is looking for more members. If you would like to get involved please email<EMAIL_ADDRESS>Using a Raspberry Pi 3 and camera module (Camera Video Module for Raspberry Pi Model A/B/B+, Pi 2 and Raspberry Pi 3), we created a sunset timelapse.
A web application that allows NYU students to share and find job opportunities / conferences / events that would be relevant for the NYU community. It’s a platform for students, by students.
Using open source software to set up a Raspberry Pi to work as a smart speaker utilizing Amazon's AI, Alexa, and developing open source Alexa Skills to be used on the Raspberry Pi smart speaker.
A webserver can refer to either software, hardware or a combination of the two working in unison. A web server is a computer that stores a websites in the form of documents and data, including HTML files, images, videos, etc and renders them to users when they are requested.
The game is an infinite runner about a squirrel in the forest. Similar to Temple Run and Canabalt.
We are working on building a full functional ecommerce website like Amazon,ebay etc. The main focus will be on learning the most popular Frontend & Backend technologies while working on the site.


WITNESS LIST Public Education Committee (Subcommittee on Safe Schools) March 3, 1997-3:00P HB 121 For: Arnold, Paula (HISD) Casey, Arthur (Coleman ISD) Hodgins, David (TASA) Howton, Nelda (herself, school admin.) Taebel, Holly (TCTA) Wall, Marjorie (TSTA) On: Hartman, Eric (TFT) HB 217 For: Wall, Marjorie (TSTA) On: Hartman, Eric (TFT) Taebel, Holly (TCTA) HB 351 For: Arnold, Paula (HISD) Boehme, Sylvia Lynn (herself & TX Assc Alt E) Garcia, Sylvia (TX Assc. for Alt. Ed.) Hartman, Eric (TFT) Hodgins, David (TASA) Lillie, Wade G. (TX Assc. for Alt. Ed.) Taebel, Holly (TCTA) Wall, Marjorie (TSTA) HB 389 For: Boehme, Sylvia Lynn (herself & TX Ass Alt Ed) Nardone, Jim (himself and El Paso ISD) Rowell, Ron (himself and Clint ISD) Taebel, Holly (TCTA) Against: Arnold, Paula (HISD) On: Hartman, Eric (TFT) Hodgins, David (TASA) HB 824 For: Arnold, Paula (HISD) Hartman, Eric (TFT) Hodgins, David (TASA) Madden, Don (Taft ISD Super.) Pierce, Denise (TASB) Taebel, Holly (TCTA) Thedford, Joe (Gregory Portland ISD) Wall, Marjorie (TSTA) HB 825 For: Hartman, Eric (TFT) Madden, Don (Taft ISD Super.) Pierce, Denise (TASB) Taebel, Holly (TCTA) Thedford, Joe (Gregory Portland ISD) Wall, Marjorie (TSTA) HB 1226 For: Dewey, Andrew (himself, teacher) Goodall, Steve (himself, teacher) Hartman, Eric (TFT) Hodgins, David (TASA) Jennings, Steven (himself, NE Fed Tchrs) Malfaro, Louis (Austin Fed. of Teachers) Taebel, Holly (TCTA) Wall, Marjorie (TSTA) HB 1227 For: Wall, Marjorie (TSTA) Against: Dewey, Andrew (himself, teacher) Goodall, Steve (himself, teacher) Hartman, Eric (TFT) Jennings, Steven (himself, NE Fed Tchrs) Malfaro, Louis (Austin Fed. of Teachers) On: Taebel, Holly (TCTA) Safe Schools On: Bieser, Jenna (ATPE) Casey, Arthur (Coleman ISD) Costilla, Esteban (himself, student) Goodall, Steve (himself, teacher) Jennings, Steven (himself & NE Fed Tchrs) Koeltzow, Paul (himself) Malfaro, Louis (Austin Fed. of Teachers) Moreno, Gilbert (himself and son) Scott, George H. (Tax Research Assc.)


Metabolite sets enrichment analysis.
mseAnalysis(metabolite.id, species = c("hsa", "dme", "mmu", "rat", "bta", "gga", "dre", "cel", "sce", "ath", "smm", "pfa", "tbr", "eco", "ppu", "syf"), test.method = c("hypergeometric", "fisher"))
| metabolite.id | The vector of metabolite IDs. |
|---|---|
| species | The species. "hsa" is Homo sapiens (human), "dme" is Drosophlia melanogaster (fruit fly), "mmu" is Mus musculus (mouse), "rat" is Rattus norvegicus (rat), "bta" is Bos taurus (cow), "gga" is Gallus domesticus (chicken), "dre" is Danio rerio (zebrafish), "cel" is Caenorharomyces elegans (nematode), "sce" is Saccharomyces cerevisaiae (yeast), "ath" is Arabidopsis thaliana (thale cress), "smm" is Schistosoma mansoni, "pfa" is Plasmodum falciparum 3D7, "tbr" is Trypanosoma brucei, "eco" is Escherichia coli K-12 MG1655, "ppu" is Pseudomonas putida KT2440, "syf" is Synechococcus elongatus. |
| test.method | Hypergeometric or fisher test. |
The MSE analysis result.


Start your search for your full time professional job early in the fall semester if you are graduating in May
|
Expand your professional wardrobe for interviews
|
Attend Career Fiesta, the Business Career Fair and any recruiter networking events
|
Be vigilant about reviewing at least weekly new listing on the Sun Devil Career Link and insuring that you apply in a timely manner
|
Refine and update your resume
|
Revise and practice your 30 second commercial
|
Thoroughly prepare for every interview you have and follow up with the appropriate correspondence
|
Evaluate and compare job offers carefully
|
Accept the position with the best fit for your goals and notify all of the other employers with whom you have interviewed that you are withdrawing from further consideration
|
Complete the W. P. Carey School of Business Employment Survey to report your new position
|


During form validation AngularJS stores context inside special controller FormController
where can be
explored all errors that are present above the given form. If you name form by some name, the controller will be
injected into the scope with the given name.
For example on the basic demo we have named the form exampleForm
, so that is why we
can retrieve the form controller from the scope by this name. The importance of this controller
is that it contains special object $error
that collects all errors that are currently present above the
form. To be more precise the $error
gathers all validation errors from the all controls that have
specified ngModel
– so they participate on the validation. All of the wrapped controls against the
form validation and with the
ngModel
directive can be also retrieved from the FormController
by its name, so it is appropriate
to name all controls by some name. All of these controls have also $error
object from which are collected
all errors for the whole form.
If you wish to display errors that have occurred during form validation using this library please follow next chapter. In contrast to the library way you can stay with the standard way provided by AngularJS. AngularJS provides two preferred options:
$error
object. See
section Standard way in AngularJS up to 1.3.ngMessages
. For more details
see section Standard way in AngularJS 1.3 and higher.
If you decide to use this library you can take advantage of some automatic ways how to display your validation errors.
There is validation-errors-location
directive for specifying the location of validation error messages.
This directive can be placed on the <form>
element or on the control eg. <input>
and this one overrides the directive defined on the <form>
.
Default value of validation-errors-location
directive is after{this}
and means that
validation errors will be automatically inserted and displayed after the control element where error has occured. Instead of this
you can use any function of
jqLite or jQuery for specifying
the element where to put the error message. You can use eg. after{parent()}
or after{parent().parent()}
, etc.
Another way is to use append
mode. This does the similar functionality as the previous mode after
,
but appends the errors messages after specified element. Examples: append{this}
, append{parent()}
, etc.
The last one and different way is to use explicit
mode. This mode does not insert any
errors messages automatically either. It relies on the definition of specific directive validation-errors
that takes names of controls of which validation errors should be displayed. Names can be more concretized
with the validation name eg. name[required]
.

Please notice in the example above that it is sometimes necessary to combine validation-errors
directive with the directive validation-controller
.
It is necessary if you wish to insert validation errors outside the form. This is because on the page
can be more forms and that the information to which validation-errors
relies can be lost. Otherwise if scope of the form
is not left then you can specify only the validation-errors
directive.
The standard way
of displaying errors up to AngularJS 1.3 was to use conditional directives
that checked whether $error
object contains some specific validation error.

Name is missing.

Date of birth has invalid format.

This way is straightforward, but sometimes can be lousy to specify whole path to the $error
again
and again. Another disadvantage is impossibility to address all validation errors inside one control.
The standard way
of displaying errors in AngularJS 1.3 and higher is to use new directive ngMessages
where should
be placed path to the $error
object of some control. Messages that should be displayed for control
with given $error
object are then inserted into this by specifying specieal directives ngMessage
.
This directive ngMessage
takes only the name of the validation.

Name is missing.

Name is too short.

Date of birth has invalid format.

This way is again more less straightforward, has one big feature against the conditional way. If more validation errors
happens for one control then it displays only the one. After one error disappears then it displays the another remaining
error. One disadvantage could be that we have to still specify full path the $error
object.
Another disadvantage is that automatic connection to the resources with error messages is still missing.


Please input your data:)
Enteractivity name for load()
Name:
Description:
Minimum Size:
Maxmum Size:
Number of groups: {{numgroup.length}}
GroupMember : {{x.teamMembers}}
TotalNum : {{x.teamMembers.length}}
{{ datadebug | json}}


Docstring:
Usage: qiime longitudinal feature-volatility [OPTIONS]
Identify features that are predictive of a numeric metadata column,
state_column (e.g., time), and plot their relative frequencies across
states using interactive feature volatility plots. A supervised learning
regressor is used to identify important features and assess their ability
to predict sample states. state_column will typically be a measure of
time, but any numeric metadata column can be used.
Inputs:
--i-table ARTIFACT FeatureTable[Frequency]
Feature table containing all features that should be
used for target prediction. [required]
Parameters:
--m-metadata-file METADATA...
(multiple Sample metadata file containing
arguments will be individual-id-column.
merged) [required]
--p-state-column TEXT Metadata containing collection time (state) values
for each sample. Must contain exclusively numeric
values. [required]
--p-individual-id-column TEXT
Metadata column containing IDs for individual
subjects. [optional]
--p-cv INTEGER Number of k-fold cross-validations to perform.
Range(1, None) [default: 5]
--p-random-state INTEGER
Seed used by random number generator. [optional]
--p-n-jobs INTEGER Number of jobs to run in parallel. [default: 1]
--p-n-estimators INTEGER
Range(1, None) Number of trees to grow for estimation. More trees
will improve predictive accuracy up to a threshold
level, but will also increase time and memory
requirements. This parameter only affects ensemble
estimators, such as Random Forest, AdaBoost,
ExtraTrees, and GradientBoosting. [default: 100]
--p-estimator TEXT Choices('RandomForestRegressor',
'ExtraTreesRegressor', 'GradientBoostingRegressor', 'AdaBoostRegressor',
'ElasticNet', 'Ridge', 'Lasso', 'KNeighborsRegressor', 'LinearSVR', 'SVR')
Estimator method to use for sample prediction.
[default: 'RandomForestRegressor']
--p-parameter-tuning / --p-no-parameter-tuning
Automatically tune hyperparameters using random grid
search. [default: False]
--p-missing-samples TEXT Choices('error', 'ignore')
How to handle missing samples in metadata. "error"
will fail if missing samples are detected. "ignore"
will cause the feature table and metadata to be
filtered, so that only samples found in both files
are retained. [default: 'error']
Outputs:
--o-filtered-table ARTIFACT FeatureTable[RelativeFrequency]
Feature table containing only important features.
[required]
--o-feature-importance ARTIFACT FeatureData[Importance]
Importance of each input feature to model accuracy.
[required]
--o-volatility-plot VISUALIZATION
Interactive volatility plot visualization. [required]
--o-accuracy-results VISUALIZATION
Accuracy results visualization. [required]
--o-sample-estimator ARTIFACT SampleEstimator[Regressor]
Trained sample regressor. [required]
Miscellaneous:
--output-dir PATH Output unspecified results to a directory
--verbose / --quiet Display verbose output to stdout and/or stderr
during execution of this action. Or silence output if
execution is successful (silence is golden).
--citations Show citations and exit.
--help Show this message and exit.
Import:
from qiime2.plugins.longitudinal.pipelines import feature_volatility
Docstring:
Feature volatility analysis
Identify features that are predictive of a numeric metadata column,
state_column (e.g., time), and plot their relative frequencies across
states using interactive feature volatility plots. A supervised learning
regressor is used to identify important features and assess their ability
to predict sample states. state_column will typically be a measure of time,
but any numeric metadata column can be used.
Parameters
----------
table : FeatureTable[Frequency]
Feature table containing all features that should be used for target
prediction.
metadata : Metadata
Sample metadata file containing individual_id_column.
state_column : Str
Metadata containing collection time (state) values for each sample.
Must contain exclusively numeric values.
individual_id_column : Str, optional
Metadata column containing IDs for individual subjects.
cv : Int % Range(1, None), optional
Number of k-fold cross-validations to perform.
random_state : Int, optional
Seed used by random number generator.
n_jobs : Int, optional
Number of jobs to run in parallel.
n_estimators : Int % Range(1, None), optional
Number of trees to grow for estimation. More trees will improve
predictive accuracy up to a threshold level, but will also increase
time and memory requirements. This parameter only affects ensemble
estimators, such as Random Forest, AdaBoost, ExtraTrees, and
GradientBoosting.
estimator : Str % Choices('RandomForestRegressor', 'ExtraTreesRegressor', 'GradientBoostingRegressor', 'AdaBoostRegressor', 'ElasticNet', 'Ridge', 'Lasso', 'KNeighborsRegressor', 'LinearSVR', 'SVR'), optional
Estimator method to use for sample prediction.
parameter_tuning : Bool, optional
Automatically tune hyperparameters using random grid search.
missing_samples : Str % Choices('error', 'ignore'), optional
How to handle missing samples in metadata. "error" will fail if missing
samples are detected. "ignore" will cause the feature table and
metadata to be filtered, so that only samples found in both files are
retained.
Returns
-------
filtered_table : FeatureTable[RelativeFrequency]
Feature table containing only important features.
feature_importance : FeatureData[Importance]
Importance of each input feature to model accuracy.
volatility_plot : Visualization
Interactive volatility plot visualization.
accuracy_results : Visualization
Accuracy results visualization.
sample_estimator : SampleEstimator[Regressor]
Trained sample regressor.


Lecture 9 by Nikolai Gad
München, 20. January 2021
Deducing properties of a population based on a sample.
Ie. describe a whole population based on a sample from that population.
A result is statistically significatnt when it is unlikely to occur randomly or by chance (but instead likely to be attributable to a specific cause).
But first a bit of
Random sampling the gold standard (but others can also work).
In a random sample, each subject from a population has the same probability of being sampled.
So if we know that every subject we are interested in (in the population) had an equal probability of being part of our sample, we can calculate how likely we are to get a result under certain conditions.
Imagine a bigger bag of m&m's and each m&m represents a person.
And the colour of the m&m represents the party they would vote for.
For random sampling with a large sample size n, the sampling distribution of the sample mean is approximately a normal distribution.Agresti, A., & Finlay, B. (2009). Statistical methods for the social sciences (Fourth edition). Upper Saddle River, N.J.: Pearson Prentice Hall.
So now that we know that the sampling distributions of the mean and proportions are normally distributed, we can use this information to calculate the exact probability of getting a certain sample statistic.
This depends on two things:
A test of independence between two categorical variables
If variables are independent (null hypothesis) we would not expect any proportional difference between groups on each variable.
Illustration:
| Gender | Party identification | Total | ||
|---|---|---|---|---|
| Democrat | Independent | Republican | ||
| Female | 573 (38%) | 516 (34%) | 422 (28%) | 1511 (100%) |
| Male | 386 (31%) | 475 (38%) | 399 (32%) | 1200 (100%) |
| Total | 959 | 991 | 821 | 2771 |
| Gender | Party identification | Total | ||
|---|---|---|---|---|
| Democrat | Independent | Republican | ||
| Female | 573 (522,9) | 516 (540,4) | 422 (447,7) | 1511 |
| Male | 386 (436,1) | 475 (450,6) | 399 (373,3) | 1200 |
| Total | 959 | 991 | 821 | 2771 |
Expected frequencies in parantheses.
Based on the differences between expected frequencies and observed fequencies, we can calculate our test statistic, chi2 with a formular.
Chi2 = 16,2 and df = 2
Looking up these numbers, we get a p-value < 0,001
So we can reject our null hypothesis because there is less than 5% probability that we would get our results if it was true. Ie. we reject that the two variables are independent and accept that there is some relationship.
So to recap the most important points to remember:
A bit simplified, we can say that p-values depend on:
The implications of this is:
Most often yes!
So far we have mostly counted words in different ways and calculated descriptive statistics.
But how do we compare these counts best?
Instead of counting frequency of words, we count how much more or less words occur in one text compared to another (set of) text(s).
Let us calculate which words Donald Trump used significantly more or less than other presidents in their inaugural speeches.
> TrumpKeyn <- textstat_keyness(inaugDfm, "2017-Trump")
> head(TrumpKeyn)
feature chi2 p n_target n_reference
1 obama 192.1317 0 3 0
2 we've 192.1317 0 3 0
3 america 124.2827 0 18 166
4 transferring 103.4512 0 2 0
5 politicians 103.4512 0 2 0
6 stops 103.4512 0 2 0
| "america" | All other words | Total words | |
|---|---|---|---|
| Target: Trump | 18 (1,1%) | 1642 (98,9%) | 1660 (100%) |
| Reference: All other inaugural speeches | 166 (0,1%) | 147319 (99,9%) | 147485 (100%) |
| Total | 184 (0,1%) | 148961 (99,9%) | 149145 (100%) |


This is a test page for Clipper. Use the Start Clipping button to activate the Clipper, then click on page elements to remove them.
Box 1
Box 2
Box 3
Box 4
Start Clipping


Cutups and configural processing
13 Apr 2016In the 1950s William S. Burroughs popularized an art form called the “cut-up technique.” The idea was to take existing stories (in text, audio, or video) and cut them up into pieces, and then recombine them into something new. His creations are a juxaposition of (often disturbing) imagery, chosen to fit together despite coming from different sources. Here’s a sample from The Soft Machine:
The cut-ups aren’t always coherent in the sense of having an understandable plot - sometimes Burroughs was just aiming to convey an emotion. He attributed an almost mystical quality to cut-ups, saying they could help reveal the hidden meanings in text or even serve as prophecy, since “when you cut into the present the future leaks out.” His experimental film The Cut-Ups was predictably polarizing, with some people finding it mesmerizing and others demanding their money back.
If you jump through the video a bit you’ll see that it isn’t quite as repetitive as it seems during the first minute. (I also think Burroughs would heartily approve of jumping through the movie rather than watching it from beginning to end.)
This idea of combining parts to create something new is alive and well on the internet, especially now that we are starting to amass a huge library of video and audio clips. It’s painstaking work, but there is a whole genre of videos in which clips from public figures are put together to recreate or parody existing songs, or to create totally original compositions.
Since the whole can have a meaning that is more than the sum of its parts, our brains must be somehow putting these parts together. This process is referred to as “configural processing,” since understanding what we’re hearing or seeing requires looking not just at the parts but at their configuration. Work from Uri Hasson’s lab (before I joined as a postdoc) has looked at how meaning gets pieced together throughout a story, and found a network of brain regions that help join sentences together to understand a narrative. They used stimuli very similar to the cut-ups, in which sentences were cut out and then put back together in a random order, and showed that these brain regions stopped responding consistently when the overall meaning was taken away (even though the parts were the same).
Today I (along with my PhD advisors, Fei-Fei Li and Diane Beck) have a new paper out in Cerebral Cortex, titled Human-object interactions are more than the sum of their parts (free-access link). This paper looks at how things get combined across space (rather than time) in the visual system. We were looking specifically at images containing either a person, an object, or both, and tried to find brain regions where a meaningful human-object interaction looked different from just a sum of person plus object.
In the full paper we look at a number of different brain regions, but some of the most interesting results come from the superior temporal sulcus (an area right behind the top of your ears). This area couldn’t care less about objects by themselves, and doesn’t even care much about people if they aren’t doing anything. But as soon as we put the person and object together in a meaningful way, it starts paying attention, and we can make a better-than-chance guess about what action the person is performing (in the picture you’re currently looking at) just by reading your brain activity from this region. Our current theory about this region is that it is involved in understanding the actions and intentions of other people, as I described in a previous post.
Next month I’ll be presenting at CEMS 2016 on some new work I’ve been doing with Uri and Ken Norman, where I’m trying to figure out exactly which pieces of a story end up getting combined together and how these combined representations get stored into memory. Working with real stories (like movies and TV shows) is challenging as a scientist, since usually we like our stimuli to be very tightly controlled, but these kinds of creative, meaningful stimuli can give us a window into the most interesting functions of the brain.
Comments? Complaints? Contact me @ChrisBaldassano