|
Package body bahn_fahrplan_api API Package Body for Deutsche Bahn Fahrplan REST API Source: http://data.deutschebahn.com/apis/fahrplan/ |
| Program units |
| check_error_http_status | Purpose: Check Server response HTTP error (2XX Status codes) Author: Daniel Hochleitner Created: 26.02.2016 Changed: |
| check_error_fahrplan_api | Purpose: Check DB Fahrplan API Server response for error Author: Daniel Hochleitner Created: 26.02.2016 Changed: |
| set_http_headers | Purpose: Set HTTP headers for REST calls Author: Daniel Hochleitner Created: 26.02.2016 Changed: |
| get_location_name_json | Purpose: Fahrplan Location.name Service REST Call - Search for location and stations Author: Daniel Hochleitner Created: 26.02.2016 Changed: |
| get_departure_board_json | Purpose: Fahrplan departureBoard Service REST Call - departure board for a |
| get_arrival_board_json | Purpose: Fahrplan arrivalBoard Service REST Call - arrival board for a |
| get_journey_detail_json | Purpose: Fahrplan journeyDetail Service REST Call - information about the complete route of a vehicle |
| get_location_stations_apex | Purpose: Fahrplan Location.name stations (StopLocation) inserted in APEX Collection Author: Daniel Hochleitner Created: 26.02.2016 Changed: |
| get_location_otherloc_apex | Purpose: Fahrplan Location.name other locations (CoordLocation) inserted in APEX Collection Author: Daniel Hochleitner Created: 26.02.2016 Changed: |
| get_departure_board_apex | Purpose: Fahrplan departureBoard inserted in APEX Collection Author: Daniel Hochleitner Created: 26.02.2016 Changed: |
| get_arrival_board_apex | Purpose: Fahrplan ArrivalBoard inserted in APEX Collection Author: Daniel Hochleitner Created: 26.02.2016 Changed: |
| get_journey_detail_apex | Purpose: Fahrplan journeyDetail Service inserted in APEX Collection Author: Daniel Hochleitner Created: 27.02.2016 Changed: |
| get_location_stations_pipe | Purpose: Fahrplan Location.name stations (StopLocation) as pipelined function Author: Daniel Hochleitner Created: 27.02.2016 Changed: |
| get_location_otherloc_pipe | Purpose: Fahrplan Location.name other locations (CoordLocation) as pipelined function Author: Daniel Hochleitner Created: 27.02.2016 Changed: |
| get_departure_board_pipe | Purpose: Fahrplan departureBoard as pipelined function Author: Daniel Hochleitner Created: 27.02.2016 Changed: |
| get_arrival_board_pipe | Purpose: Fahrplan ArrivalBoard as pipelined function Author: Daniel Hochleitner Created: 27.02.2016 Changed: |
| get_journey_detail_pipe | Purpose: Fahrplan journeyDetail Service as pipelined function Author: Daniel Hochleitner Created: 27.02.2016 Changed: |
check_error_http_status
PROCEDURE check_error_http_status
Purpose: Check Server response HTTP error (2XX Status codes) Author: Daniel Hochleitner Created: 26.02.2016 Changed:
check_error_fahrplan_api
PROCEDURE check_error_fahrplan_api(i_response_clob IN CLOB)
Purpose: Check DB Fahrplan API Server response for error Author: Daniel Hochleitner Created: 26.02.2016 Changed:
set_http_headers
PROCEDURE set_http_headers
Purpose: Set HTTP headers for REST calls Author: Daniel Hochleitner Created: 26.02.2016 Changed:
get_location_name_json
FUNCTION get_location_name_json(i_api_auth_key IN VARCHAR2, i_language IN VARCHAR2 := 'en', i_search_string IN VARCHAR2) RETURN CLOB
Purpose: Fahrplan Location.name Service REST Call - Search for location and stations Author: Daniel Hochleitner Created: 26.02.2016 Changed:
get_departure_board_json
FUNCTION get_departure_board_json(i_api_auth_key IN VARCHAR2, i_language IN VARCHAR2 := 'en', i_station_id IN NUMBER, i_date_time IN DATE := NULL) RETURN CLOB
Purpose: Fahrplan departureBoard Service REST Call - departure board for a
given station (id) and date/time
Author: Daniel Hochleitner Created: 26.02.2016 Changed:
get_arrival_board_json
FUNCTION get_arrival_board_json(i_api_auth_key IN VARCHAR2, i_language IN VARCHAR2 := 'en', i_station_id IN NUMBER, i_date_time IN DATE := NULL) RETURN CLOB
Purpose: Fahrplan arrivalBoard Service REST Call - arrival board for a
given station (id) and date/time
Author: Daniel Hochleitner Created: 26.02.2016 Changed:
get_journey_detail_json
FUNCTION get_journey_detail_json(i_journeydetailref_url IN VARCHAR2) RETURN CLOB
Purpose: Fahrplan journeyDetail Service REST Call - information about the complete route of a vehicle
Gets journeydetailref URL from departure or arrival board
Author: Daniel Hochleitner Created: 27.02.2016 Changed:
get_location_stations_apex
PROCEDURE get_location_stations_apex(i_api_auth_key IN VARCHAR2, i_language IN VARCHAR2 := 'en', i_search_string IN VARCHAR2, i_apex_coll_name IN VARCHAR2 := 'STATIONS')
Purpose: Fahrplan Location.name stations (StopLocation) inserted in APEX Collection Author: Daniel Hochleitner Created: 26.02.2016 Changed:
get_location_otherloc_apex
PROCEDURE get_location_otherloc_apex(i_api_auth_key IN VARCHAR2, i_language IN VARCHAR2 := 'en', i_search_string IN VARCHAR2, i_apex_coll_name IN VARCHAR2 := 'LOCATIONS')
Purpose: Fahrplan Location.name other locations (CoordLocation) inserted in APEX Collection Author: Daniel Hochleitner Created: 26.02.2016 Changed:
get_departure_board_apex
PROCEDURE get_departure_board_apex(i_api_auth_key IN VARCHAR2, i_language IN VARCHAR2 := 'en', i_station_id IN NUMBER, i_date_time IN DATE := NULL, i_apex_coll_name IN VARCHAR2 := 'DEPARTURE_BOARD')
Purpose: Fahrplan departureBoard inserted in APEX Collection Author: Daniel Hochleitner Created: 26.02.2016 Changed:
get_arrival_board_apex
PROCEDURE get_arrival_board_apex(i_api_auth_key IN VARCHAR2, i_language IN VARCHAR2 := 'en', i_station_id IN NUMBER, i_date_time IN DATE := NULL, i_apex_coll_name IN VARCHAR2 := 'ARRIVAL_BOARD')
Purpose: Fahrplan ArrivalBoard inserted in APEX Collection Author: Daniel Hochleitner Created: 26.02.2016 Changed:
get_journey_detail_apex
PROCEDURE get_journey_detail_apex(i_journeydetailref_url IN VARCHAR2, i_apex_coll_name IN VARCHAR2 := 'JOURNEY_DETAIL')
Purpose: Fahrplan journeyDetail Service inserted in APEX Collection Author: Daniel Hochleitner Created: 27.02.2016 Changed:
get_location_stations_pipe
FUNCTION get_location_stations_pipe(i_api_auth_key IN VARCHAR2, i_language IN VARCHAR2 := 'en', i_search_string IN VARCHAR2) RETURN bahn_fahrplan_api.t_location_stations_tab
Purpose: Fahrplan Location.name stations (StopLocation) as pipelined function Author: Daniel Hochleitner Created: 27.02.2016 Changed:
get_location_otherloc_pipe
FUNCTION get_location_otherloc_pipe(i_api_auth_key IN VARCHAR2, i_language IN VARCHAR2 := 'en', i_search_string IN VARCHAR2) RETURN bahn_fahrplan_api.t_location_otherloc_tab
Purpose: Fahrplan Location.name other locations (CoordLocation) as pipelined function Author: Daniel Hochleitner Created: 27.02.2016 Changed:
get_departure_board_pipe
FUNCTION get_departure_board_pipe(i_api_auth_key IN VARCHAR2, i_language IN VARCHAR2 := 'en', i_station_id IN NUMBER, i_date_time IN DATE := NULL) RETURN bahn_fahrplan_api.t_departure_tab
Purpose: Fahrplan departureBoard as pipelined function Author: Daniel Hochleitner Created: 27.02.2016 Changed:
get_arrival_board_pipe
FUNCTION get_arrival_board_pipe(i_api_auth_key IN VARCHAR2, i_language IN VARCHAR2 := 'en', i_station_id IN NUMBER, i_date_time IN DATE := NULL) RETURN bahn_fahrplan_api.t_arrival_tab
Purpose: Fahrplan ArrivalBoard as pipelined function Author: Daniel Hochleitner Created: 27.02.2016 Changed:
get_journey_detail_pipe
FUNCTION get_journey_detail_pipe(i_journeydetailref_url IN VARCHAR2) RETURN bahn_fahrplan_api.t_journey_tab
Purpose: Fahrplan journeyDetail Service as pipelined function Author: Daniel Hochleitner Created: 27.02.2016 Changed:


Hind BioScience Standalone September 2019 Net Sales at Rs 0.14 crore, down 90.54% Y-o-Y
Reported Standalone quarterly numbers for Hindustan Bio Science are:
Net Sales at Rs 0.14 crore in September 2019 down 90.54% from Rs. 1.47 crore in September 2018.
Quarterly Net Loss at Rs. 0.14 crore in September 2019 down 710.73% from Rs. 0.02 crore in September 2018.
EBITDA stands negative at Rs. 0.14 crore in September 2019 down 800% from Rs. 0.02 crore in September 2018.
Hind BioScience shares closed at 2.70 on October 31, 2019 (BSE)
| Hindustan Bio Science | |
| Standalone Quarterly Results | in Rs. Cr. |
| Sep'19 | Jun'19 | Sep'18 | |
| Net Sales/Income from operations | 0.14 | 0.58 | 1.47 |
| Other Operating Income | -- | -- | -- |
| Total Income From Operations | 0.14 | 0.58 | 1.47 |
| EXPENDITURE | |||
| Consumption of Raw Materials | -- | -- | -- |
| Purchase of Traded Goods | 0.06 | 0.50 | 1.60 |
| Increase/Decrease in Stocks | 0.09 | -0.19 | -0.24 |
| Power & Fuel | -- | -- | -- |
| Employees Cost | 0.06 | 0.06 | 0.05 |
| Depreciation | 0.00 | 0.00 | 0.00 |
| Excise Duty | -- | -- | -- |
| Admin. And Selling Expenses | -- | 0.00 | 0.00 |
| R & D Expenses | -- | -- | -- |
| Provisions And Contingencies | -- | -- | -- |
| Exp. Capitalised | -- | -- | -- |
| Other Expenses | 0.05 | 0.06 | 0.03 |
| P/L Before Other Inc. , Int., Excpt. Items & Tax | -0.14 | 0.14 | 0.02 |
| Other Income | -- | -- | -- |
| P/L Before Int., Excpt. Items & Tax | -0.14 | 0.14 | 0.02 |
| Interest | 0.00 | 0.00 | 0.00 |
| P/L Before Exceptional Items & Tax | -0.14 | 0.14 | 0.02 |
| Exceptional Items | -- | -- | -- |
| P/L Before Tax | -0.14 | 0.14 | 0.02 |
| Tax | -- | -- | -- |
| P/L After Tax from Ordinary Activities | -0.14 | 0.14 | 0.02 |
| Prior Year Adjustments | -- | -- | -- |
| Extra Ordinary Items | -- | -- | -- |
| Net Profit/(Loss) For the Period | -0.14 | 0.14 | 0.02 |
| Equity Share Capital | 10.25 | 10.25 | 10.25 |
| Reserves Excluding Revaluation Reserves | -- | -- | -- |
| Equity Dividend Rate (%) | -- | -- | -- |
| EPS Before Extra Ordinary | |||
| Basic EPS | -0.14 | 0.14 | 0.02 |
| Diluted EPS | -0.14 | 0.14 | 0.02 |
| EPS After Extra Ordinary | |||
| Basic EPS | -0.14 | 0.14 | 0.02 |
| Diluted EPS | -0.14 | 0.14 | 0.02 |
| Public Share Holding | |||
| No Of Shares (Crores) | -- | -- | -- |
| Share Holding (%) | -- | -- | -- |
| Promoters and Promoter Group Shareholding | |||
| a) Pledged/Encumbered | |||
| - Number of shares (Crores) | -- | -- | -- |
| - Per. of shares (as a % of the total sh. of prom. and promoter group) | -- | -- | -- |
| - Per. of shares (as a % of the total Share Cap. of the company) | -- | -- | -- |
| b) Non-encumbered | |||
| - Number of shares (Crores) | -- | -- | -- |
| - Per. of shares (as a % of the total sh. of prom. and promoter group) | -- | -- | -- |
| - Per. of shares (as a % of the total Share Cap. of the company) | -- | -- | -- |
| Source : Dion Global Solutions Limited |


The file attachments module contains two components to add files to forms and display summary information about attachments.
The sky-file-drop
component provides an element that users can click to select files from their local drives or use as a drop zone to drag and drop files. The component can also display controls for users to provide hyperlinks to files on the web. You can leave the contents of the component blank to display the drop zone's default UI, or you can specify custom content to display instead.
When the SKY UX module initializes, it disables the ability to drag and drop files for the entire window. This prevents the browser from opening files that are accidentally dropped outside the target zone. If you implement your own file drop functionality outside of the file drop component, you can place the sky-file-drop-target
CSS class on the element that receives drop events to exempt it from the drop exclusion rule.
The sky-file-item
component displays summary information about files that users attach to forms. By default, the component displays file names, delete buttons, and fields for names and tags.. For files from local drives, the component also displays file sizes and thumbnails.
[validateFn]="validateFile"
). By default, any type of file is allowed.
[acceptedTypes]="validFileTypes"
or acceptedTypes="image/png,image/jpeg"
). By default, any type of file is allowed.


var game = new Phaser.Game(800, 600, Phaser.AUTO, 'phaser-example', { preload: preload, create: create, update: update });
function preload() {
game.load.image('phaser', 'assets/sprites/phaser-dude.png');
game.load.image('bullet', 'assets/misc/bullet0.png');
}
var sprite;
var bullet;
var bullets;
var bulletTime = 0;
// Left, right and space key for controls
var leftKey;
var rightKey;
var spaceKey;
// Helpful text display for justPressed functions.
var textLeft;
var textRight;
var textSpace;
var textLeft2;
var textRight2;
var textSpace2;
function create() {
game.physics.startSystem(Phaser.Physics.ARCADE);
game.stage.backgroundColor = '#2d2d2d';
bullets = game.add.group();
bullets.enableBody = true;
bullets.physicsBodyType = Phaser.Physics.ARCADE;
bullets.createMultiple(10, 'bullet');
bullets.callAll('events.onOutOfBounds.add', 'events.onOutOfBounds', resetBullet, this);
bullets.setAll('checkWorldBounds', true);
sprite = game.add.sprite(400, 550, 'phaser');
game.physics.enable(sprite, Phaser.Physics.ARCADE);
// Register the keys.
this.leftKey = game.input.keyboard.addKey(Phaser.Keyboard.LEFT);
this.rightKey = game.input.keyboard.addKey(Phaser.Keyboard.RIGHT);
this.spaceKey = game.input.keyboard.addKey(Phaser.Keyboard.SPACEBAR);
// Stop the following keys from propagating up to the browser
game.input.keyboard.addKeyCapture([ Phaser.Keyboard.LEFT, Phaser.Keyboard.RIGHT, Phaser.Keyboard.SPACEBAR ]);
// Add some debugging text.
this.textLeft = game.add.text(20, 20, "Left was pressed 250 ms ago? NO", { font: "16px Arial", fill: "#ffffff", align: "center" });
this.textRight = game.add.text(20, 60, "Right was pressed 500 ms ago? NO", { font: "16px Arial", fill: "#ffffff", align: "center" });
this.textSpace = game.add.text(20, 100, "Space was pressed 1000 ms ago? NO", { font: "16px Arial", fill: "#ffffff", align: "center" });
this.textLeft2 = game.add.text(600, 20, "Is left still down? NO", { font: "16px Arial", fill: "#ffffff", align: "center" });
this.textRight2 = game.add.text(600, 60, "Is right still down? NO", { font: "16px Arial", fill: "#ffffff", align: "center" });
this.textSpace2 = game.add.text(600, 100, "Is space still down? NO", { font: "16px Arial", fill: "#ffffff", align: "center" });
}
function update() {
sprite.body.velocity.x = 0;
sprite.body.velocity.y = 0;
// If true, it means that this key is down. If not, it means that the key is not down (was released/not pressed)
if (this.leftKey.isDown)
{
sprite.body.velocity.x = -200;
this.textLeft2.text = "Is left still down? YES";
}
else
{
this.textLeft2.text = "Is left still down? NO";
}
if (this.rightKey.isDown)
{
sprite.body.velocity.x = 200;
this.textRight2.text = "Is right still down? YES";
}
else
{
this.textRight2.text = "Is right still down? NO";
}
if (this.spaceKey.isDown)
{
fireBullet();
this.textSpace2.text = "Is space still down? YES";
}
else
{
this.textSpace2.text = "Is space still down? NO";
}
// downDuration (previously called 'justPressed') does not schedule key pressing, it's merely indicative
// of key states.
//
// In this case the downDuration function tells us that between this current time and 250 milliseconds ago,
// this key was pressed (not the same as holding down) and if it was pressed between that slice of time, it returns
// true, otherwise false.
if (this.leftKey.downDuration(250))
{
this.textLeft.text = "Left was pressed 250 ms ago? YES";
}
else
{
this.textLeft.text = "Left was pressed 250 ms ago? NO";
}
if (this.rightKey.downDuration(500))
{
this.textRight.text = "Right was pressed 500 ms ago? YES";
}
else
{
this.textRight.text = "Right was pressed 500 ms ago? NO";
}
if (this.spaceKey.downDuration(1000))
{
this.textSpace.text = "Space was pressed 1000 ms ago? YES";
}
else
{
this.textSpace.text = "Space was pressed 1000 ms ago? NO";
}
}
function fireBullet () {
if (game.time.now > bulletTime)
{
bullet = bullets.getFirstExists(false);
if (bullet)
{
bullet.reset(sprite.x + 6, sprite.y - 8);
bullet.body.velocity.y = -300;
bulletTime = game.time.now + 250;
}
}
}
// Called if the bullet goes out of the screen
function resetBullet (bullet) {
bullet.kill();
}


Resources:
During the development of my SMS emulator I found the following resources most helpful.
SMSPower: smspower.org is a haven for all things SMS. It contains development ROM images, great documentation and much more. A lot of the resources I used can be found on this site. As requested by SMSPower I shall not link directly to their documentation or upload it to my own site. Instead I shall link to their documentation and wiki section of their site for you to locate the resource from their.
Z80 Documentation- Hex Opcodes: This is a lookup table for Z80 hex opcodes which maps them to their mnemonics. Author Unknown
- Z80 Info: This shows all the mnemoics for the Z80, how each works, what flags they affect and their timing. Author Sean Young
- Z80 Opcodes: This is a great resource for detailed informtation of the Z80 Instructions. Especially the Chapter on the flags. Author James Moxham
- Z80 Flag Affection: Another good resource for how opcodes affect the flags. Author Sean Young
- SMS/GG hardware notes (2002/11/12): Great documetion covering everything about the SMS. Author Charles MacDonald
- Sega Master System Technical Information: Similar to Charles MacDonalds document. It is sometimes handy to compare and contrast diffent resources. Author Richard Talbot-Watkins
- Memory Mapping: Contains everything you need to emulate the different memory mappers. Author Maxim
- SMS VDP Documentation (2002/11/12): This covers everthing you need to emulate the main vdp mode used in 99.9% of SMS games. Author Charles MacDonald
- Sega Master System Technical Information: The VDP section of this document is also good to use along with Charles MacDonald's. Author Richard Talbot-Watkins
- TMS9918A Document: This covers the other VDP mode used for the remaining 0.1% of SMS games (aka F-16 Fighter). Author Sean Young
- SN79489 notes: The only document I needed to emulate the SMS sound chip. Author Maxim


Here is a list of my talks:
Practical fuzzing in Go
Modern web security features (feat.  Stefano Zanero)
GoTimeFm podcast episodes:
Slide Karaoke


DRAMA
Multeen Players take to the stage with The Mating Season
by ReporterThe newly formed Multeen Players Drama Group will be performing Sam Crees hilarious comedy The Mating Season in Knockavilla Hall for a three night run on December 6, 7 and 8 at 8pm.
The Multeen Players are the first local drama group to put on a show in Knockavilla in over 40 years.
The Mating Season is a comedy in which widower Sid Gillespie, seeking to marry Stella Morley, attempts first to clear the way by matchmaking his two sons, and likewise sorting out housekeeper Mrs. Jamieson and his old uncle Fred.
Cast
Conor O'Mahony stars as Mervyn Gillespie, Kate Maher as Mrs Jamieson, Paul Maher as Fred Woods, Kieren Slattery as Sid Gillespie, Elaine Breen as Stella Morley, Jim O'Dwyer as Robin Gillespie, Karen Cummins as Vanessa Morley, Laura Cahill as Barbara Nixon, Zoe Curling as Helga Herdman and Fiona Kennedy as Violet Harris.
The play is being produced by the brilliant Jim Keane with the cast a mix of both experienced members and also some members giving their debut performances. This is a show not to be missed.
Tickets are available from Heffernans Shop and Butlers Centra in Dundrum or can be got by calling the booking number<PHONE_NUMBER>.


Descender space of a strut generated from a replaced element is drawn on hover when the element's background color is initially transparent, and a background color value is set on hover, and when the document has a 'transitional' doctype declaration
Test passes if when you hover over the image, the 'TEST' test does not move
TEST


<sep>
The <sep>
element defines a separator character that is inline with the
content of a syntax diagram. The separator occurs between keywords, operators or groups in
a syntax definition. This element is part of the DITA programming domain, a special set of
DITA elements designed to document programming tasks, concepts, and reference
information.
Category: Programming elements


JFS is an implementation of virtual file storage for javac, the Java compiler, over in-memory storage, for extremely fast compilation and execution of dynamically generated Java code.


wiki / software / acpid Edit this page
Edited (416d7ab) at 2020-06-29 by ectlunya
ACPID
________________________________________________________________________________
Acpid is a daemon that executes certain actions whenever ACPI events are
received. Depending on your hardware and kernel configuration, these events
include closing a laptop lid, connecting to an AC power adapter, pressing
buttons and more.
Index
________________________________________________________________________________
- Usage [0.0]
- Kernel Setup [1.0]
- Busybox acpid [2.0]
- acpid2 [3.0]
[0.0] Usage
________________________________________________________________________________
KISS Linux offers two options for acpid management: busybox acpid, which is
installed by default, and acpid2 [1], which can be installed with the acpid
package. To use either version of acpid, you will need to enable a few kernel
options and enable the acpid service. See @/init/busybox.
[1.0] Kernel Setup
________________________________________________________________________________
ACPI-related kernel drivers must be enabled for acpid to function properly. In
menuconfig, these options are found under Power management and ACPI options
> Power Management support > ACPI support. Most of the drivers are
self-explanatory, but the following notable options can be safely disabled:
+------------------------------------------------------------------------------+
| |
| CONFIG_ACPI_PROCFS_POWER This option is deprecated |
| CONFIG_ACPI_EC_DEBUGFS Potentially interferes with reboot |
| CONFIG_ACPI_TABLE_UPGRADE KISS does not use an initrd by default |
| CONFIG_ACPI_DEBUG Adds 50k to kernel size |
| CONFIG_ACPI_PCI_SLOT Usually unnecessary |
| CONFIG_ACPI_CUSTOM_METHOD Potential security flaw |
| |
+------------------------------------------------------------------------------+
[2.0] Busybox acpid
________________________________________________________________________________
When events are received, acpid checks /etc/acpi.map for a matching event and
/etc/acpid.conf for a corresponding handler script in /etc/acpi/ to execute.
Create the files below to suspend your laptop whenever the lid is closed:
+------------------------------------------------------------------------------+
| /etc/acpi.map |
+------------------------------------------------------------------------------+
| |
| EV_SW 0x05 SW_LID 0 1 button/lid LID0 00000080 |
| |
+------------------------------------------------------------------------------+
| /etc/acpid.conf |
+------------------------------------------------------------------------------+
| |
| LID0 LID/00000080 |
| |
+------------------------------------------------------------------------------+
| /etc/acpi/LID/00000080 |
+------------------------------------------------------------------------------+
| |
| #!/bin/sh |
| |
| printf mem > /sys/power/state |
| |
+------------------------------------------------------------------------------+
Each line in /etc/acpi.map has six space-delimited fields:
1. Type name (EV_SW),
2. Type numerical value (0x05)
3. Keycode name (SW_LID)
4. Keycode numerical value (0)
5. Value (1)
6. Description (button/lid LID0 00000080)
Event types and keycodes are listed in /usr/include/linux/input-event-codes.h.
For example, a keyboard WLAN button event would use EV_KEY 0x05 and KEY_WLAN
238. The event value should be 1 and the event description can be any string
potentially including spaces.
Each line in /etc/acpid.conf has a key (LID0) and an action (LID/00000080). The
key is any unique substring of the event description in /etc/acpi.map and the
action is the relative path to an executable script in /etc/acpi/.
To see if a configured event is received, check /var/log/acpid.log for output
lines that list the path of your handler scripts.
[3.0] acpid2
________________________________________________________________________________
acpid2 is a more user-friendly version of acpid that avoids the tedious process
of mapping events with flexible configuration and better documentation. The
acpid package also installs acpi_listen which prints events as they occur. For
example, pressing the volume mute button will print something like this:
+------------------------------------------------------------------------------+
| |
| button/mute MUTE 00000080 00000000 K |
| |
+------------------------------------------------------------------------------+
When events are received, acpid2 checks files in /etc/acpi/event/ for a matching
event and a corresponding handler script to execute. Create the following files
to handle the mute button event by toggling the Master audio channel:
+------------------------------------------------------------------------------+
| /etc/acpi/event/anything |
+------------------------------------------------------------------------------+
| |
| event=.* |
| action=/etc/acpi/handler.sh %e |
| |
+------------------------------------------------------------------------------+
| /etc/acpi/handler.sh |
+------------------------------------------------------------------------------+
| |
| #!/bin/sh |
| |
| case $1 in |
| button/mute) |
| amixer sset Master toggle |
| ;; |
| esac |
| |
+------------------------------------------------------------------------------+
Files in /etc/acpi/event/ match events using event=REGEX with an action to
execute. In this example, .* matches all events and the action executes
/etc/acpi/handler.sh. The argument %e expands to five event parameters:
$1=button/mute, $2=MUTE, $3=00000080, $4=00000000, $5=K. The event parameters
provide an easy way to handle all events in a single script instead of the more
complex multi-file system used by busybox.
References
________________________________________________________________________________
[0] https://sourceforge.net/projects/acpid2
________________________________________________________________________________
Dylan Araps (C) 2019-2020
kiss-community (C) 2020-2021
Dilyn Corner (C) 2021
Linux(R) is the registered trademark of Linus Torvalds in the U.S. and
other countries.


Changes Salon and Day Spa is a unique venue to relax, de-stress and get gorgeous. At Changes, we are dedicated to providing the most innovative beauty and wellness services in a beautiful and relaxing environment. With 18 hair stations, 11 treatment rooms, a semi-private pedicure room with a 16 foot water wall, Aqua Terra relaxation room, men’s and women’s locker rooms with steam lounges and 60 talented team members we will meet all your salon and spa needs. Centrally located at the corner of Lincoln and N. Broadway in Downtown Walnut Creek, visit us and find out why Changes has been voted The Best of The East Bay over 30 times.


;
Calculates the midpoint between two pairs of (x,y) points.
- Destructure the array to get
x1
, y1
, x2
and y2
.
- Calculate the midpoint for each dimension by dividing the sum of the two endpoints by
2
.
midpoint([2, 2], [4, 4]); // [3, 3]
midpoint([4, 4], [6, 6]); // [5, 5]
midpoint([1, 3], [2, 4]); // [1.5, 3.5]


Design Principles behind Akka Streams
It took quite a while until we were reasonably happy with the look and feel of the API and the architecture of the implementation, and while being guided by intuition the design phase was very much exploratory research. This section details the findings and codifies them into a set of principles that have emerged during the process.
Note
As detailed in the introduction keep in mind that the Akka Streams API is completely decoupled from the Reactive Streams interfaces which are just an implementation detail for how to pass stream data between individual processing stages.
What shall users of Akka Streams expect?
Akka is built upon a conscious decision to offer APIs that are minimal and consistent—as opposed to easy or intuitive. The credo is that we favor explicitness over magic, and if we provide a feature then it must work always, no exceptions. Another way to say this is that we minimize the number of rules a user has to learn instead of trying to keep the rules close to what we think users might expect.
From this follows that the principles implemented by Akka Streams are:
- all features are explicit in the API, no magic
- supreme compositionality: combined pieces retain the function of each part
- exhaustive model of the domain of distributed bounded stream processing
This means that we provide all the tools necessary to express any stream processing topology, that we model all the essential aspects of this domain (back-pressure, buffering, transformations, failure recovery, etc.) and that whatever the user builds is reusable in a larger context.
Akka Streams does not send dropped stream elements to the dead letter office
One important consequence of offering only features that can be relied upon is the restriction that Akka Streams cannot ensure that all objects sent through a processing topology will be processed. Elements can be dropped for a number of reasons:
- plain user code can consume one element in a map(...) stage and produce an entirely different one as its result
- common stream operators drop elements intentionally, e.g. take/drop/filter/conflate/buffer/…
- stream failure will tear down the stream without waiting for processing to finish, all elements that are in flight will be discarded
- stream cancellation will propagate upstream (e.g. from a take operator) leading to upstream processing steps being terminated without having processed all of their inputs
This means that sending JVM objects into a stream that need to be cleaned up will require the user to ensure that this happens outside of the Akka Streams facilities (e.g. by cleaning them up after a timeout or when their results are observed on the stream output, or by using other means like finalizers etc.).
Resulting Implementation Constraints
Compositionality entails reusability of partial stream topologies, which led us to the lifted approach of describing data flows as (partial) graphs that can act as composite sources, flows (a.k.a. pipes) and sinks of data. These building blocks shall then be freely shareable, with the ability to combine them freely to form larger graphs. The representation of these pieces must therefore be an immutable blueprint that is materialized in an explicit step in order to start the stream processing. The resulting stream processing engine is then also immutable in the sense of having a fixed topology that is prescribed by the blueprint. Dynamic networks need to be modeled by explicitly using the Reactive Streams interfaces for plugging different engines together.
The process of materialization will often create specific objects that are useful to interact with the processing engine once it is running, for example for shutting it down or for extracting metrics. This means that the materialization function produces a result termed the materialized value of a graph.
Interoperation with other Reactive Streams implementations
Akka Streams fully implement the Reactive Streams specification and interoperate with all other conformant implementations. We chose to completely separate the Reactive Streams interfaces from the user-level API because we regard them to be an SPI that is not targeted at endusers. In order to obtain a Publisher or Subscriber from an Akka Stream topology, a corresponding Sink.asPublisher or Source.asSubscriber element must be used.
All stream Processors produced by the default materialization of Akka Streams are restricted to having a single Subscriber, additional Subscribers will be rejected. The reason for this is that the stream topologies described using our DSL never require fan-out behavior from the Publisher sides of the elements, all fan-out is done using explicit elements like Broadcast[T].
This means that Sink.asPublisher(true) (for enabling fan-out support) must be used where broadcast behavior is needed for interoperation with other Reactive Streams implementations.
What shall users of streaming libraries expect?
We expect libraries to be built on top of Akka Streams, in fact Akka HTTP is one such example that lives within the Akka project itself. In order to allow users to profit from the principles that are described for Akka Streams above, the following rules are established:
- libraries shall provide their users with reusable pieces, i.e. expose factories that return graphs, allowing full compositionality
- libraries may optionally and additionally provide facilities that consume and materialize graphs
The reasoning behind the first rule is that compositionality would be destroyed if different libraries only accepted graphs and expected to materialize them: using two of these together would be impossible because materialization can only happen once. As a consequence, the functionality of a library must be expressed such that materialization can be done by the user, outside of the library’s control.
The second rule allows a library to additionally provide nice sugar for the common case, an example of which is the Akka HTTP API that provides a handleWith method for convenient materialization.
Note
One important consequence of this is that a reusable flow description cannot be bound to “live” resources, any connection to or allocation of such resources must be deferred until materialization time. Examples of “live” resources are already existing TCP connections, a multicast Publisher, etc.; a TickSource does not fall into this category if its timer is created only upon materialization (as is the case for our implementation).
Exceptions from this need to be well-justified and carefully documented.
Resulting Implementation Constraints
Akka Streams must enable a library to express any stream processing utility in terms of immutable blueprints. The most common building blocks are
- Source: something with exactly one output stream
- Sink: something with exactly one input stream
- Flow: something with exactly one input and one output stream
- BidiFlow: something with exactly two input streams and two output streams that conceptually behave like two Flows of opposite direction
- Graph: a packaged stream processing topology that exposes a certain set of input and output ports, characterized by an object of type Shape.
Note
A source that emits a stream of streams is still just a normal Source, the kind of elements that are produced does not play a role in the static stream topology that is being expressed.
The difference between Error and Failure
The starting point for this discussion is the definition given by the Reactive Manifesto. Translated to streams this means that an error is accessible within the stream as a normal data element, while a failure means that the stream itself has failed and is collapsing. In concrete terms, on the Reactive Streams interface level data elements (including errors) are signaled via onNext while failures raise the onError signal.
Note
Unfortunately the method name for signaling failure to a Subscriber is called onError for historical reasons. Always keep in mind that the Reactive Streams interfaces (Publisher/Subscription/Subscriber) are modeling the low-level infrastructure for passing streams between execution units, and errors on this level are precisely the failures that we are talking about on the higher level that is modeled by Akka Streams.
There is only limited support for treating onError in Akka Streams compared to the operators that are available for the transformation of data elements, which is intentional in the spirit of the previous paragraph. Since onError signals that the stream is collapsing, its ordering semantics are not the same as for stream completion: transformation stages of any kind will just collapse with the stream, possibly still holding elements in implicit or explicit buffers. This means that data elements emitted before a failure can still be lost if the onError overtakes them.
The ability for failures to propagate faster than data elements is essential for tearing down streams that are back-pressured—especially since back-pressure can be the failure mode (e.g. by tripping upstream buffers which then abort because they cannot do anything else; or if a dead-lock occurred).
The semantics of stream recovery
A recovery element (i.e. any transformation that absorbs an onError signal and turns that into possibly more data elements followed normal stream completion) acts as a bulkhead that confines a stream collapse to a given region of the stream topology. Within the collapsed region buffered elements may be lost, but the outside is not affected by the failure.
This works in the same fashion as a try–catch expression: it marks a region in which exceptions are caught, but the exact amount of code that was skipped within this region in case of a failure might not be known precisely—the placement of statements matters.
Contents


INSTRUCTION FORM
14 August 2020
Ref: 00005.200814.Q7
John Doe
KP Acoustics Ltd. fe
By email to:f43f
Dear
Further to your recent enquiry, we are pleased to present you with our scope of work and fee proposal for the above project.
This is random text number 4 guys, because I could not find it now, but who found can edit service when he wants.
Following the assessment of the sound insulation performance of the existing constructions, we would review any available construction details in parallel with the survey results in order to recommend any acoustic treatment and detailing as necessary.
The current construction performances will be reviewed against the requirements of the Building Regulations, Approved Document E: ‘Resistance to the passage of sound’ (2003 Edition).
The review would consider the requirements of the Building Regulations and any other relevant British Standard as well as any specific client performance requirements.
A bespoke sound insulation upgrade solution, dependent on budgetary and performance requirements would be proposed within our report, with references to proprietary materials and suppliers as appropriate.
This is random text number 4 guys, because I could not find it now, but who found can edit service when he wants.
Following the assessment of the sound insulation performance of the existing constructions, we would review any available construction details in parallel with the survey results in order to recommend any acoustic treatment and detailing as necessary.
The current construction performances will be reviewed against the requirements of the Building Regulations, Approved Document E: ‘Resistance to the passage of sound’ (2003 Edition).
The review would consider the requirements of the Building Regulations and any other relevant British Standard as well as any specific client performance requirements.
A bespoke sound insulation upgrade solution, dependent on budgetary and performance requirements would be proposed within our report, with references to proprietary materials and suppliers as appropriate.
Our lump sum fees for undertaking the above scope of work would be as follows:
| A.1: Site Visit/Inspection | £6009 (+VAT) |
| A.2: Site Visit/Inspection | £6009 (+VAT) |
The above fees are exclusive of VAT which will be charged at the prevailing rate, but inclusive of out of pocket expenses with the exception of air fares, hotel accommodation and visa costs. A clearance of 50% of the above fee would be required prior to undertaking any work, with the remaining funds to clear after the completion of the scope of work, or part thereof. Invoices will be raised to reflect the above payment schedule.
Please note that this scope of work reflects the time for office work, commensurate to the type and size of the project.
Each revision of the noise modelling calculations and our technical report due to new information provided by the Client (such as, but not limited to, Gantt charts, equipment operations, or durations), would be charged at £650.00 (+VAT) as a fixed lump sum.
Any additional input for description amendments, or other Client requests will be charged at our standard hourly rate of £120.00 (+VAT).
Site visits, or meetings in will only be undertaken with prior approval from yourselves with a
The overall procedure would be facilitated with the provision of any site plans, installation proposals (schedules, services drawings, and manufacturer’s noise emissions data) and/or relevant planning conditions. Copies of liaison / correspondence between relevant parties would be required where the subject matter is relevant.
We trust that the above is satisfactory for your requirements. Should you have any questions, please do not hesitate to contact us.
Yours Sincerely,
George Hadjilambri AMIOA
KP Acoustics Ltd.
1 Galena Road
London
W6 0LT
T: +44(0)208 222 8778
F: +44(0)208 222 8575
email<EMAIL_ADDRESS>| Client Name | |
| Invoicing Address | |
| Accounts Email Address | |
| Purchase Order Number | |
| Contact telephone numbers | |
| Site Contact | |
| Site full postall address |
| This is a formal appointment of KP Acoustics Ltd. to undertake and fulfil the scope of work referenced 20982.200611.Q1. Terms of contract of KP Acoustics Ltd. can be provided upon request. |
| Print Name: |
| Date: |


{% extends "base.html" %} {% block body_content %}
Auth with GitHub to track your repos.
Please login or signup.


|
Global-reservation_DOC
0.1
|
Welcome to the Symfony Standard Edition - a fully-functional Symfony2 application that you can use as the skeleton for your new app. If you want to learn more about the features included, see the "What's Inside?" section.
This document contains information on how to download and start using Symfony. For a more detailed explanation, see the Installation chapter of the Symfony Documentation.
If you've already downloaded the standard edition, and unpacked it somewhere within your web root directory, then move on to the "Installation" section.
To download the standard edition, you have two options:
The easiest way to get started is to download an archive of the standard edition (http://symfony.com/download). Unpack it somewhere under your web server root directory and you're done. The web root is wherever your web server (e.g. Apache) looks when you access http://localhost
in a browser.
We highly recommend that you download the packaged version of this distribution.
Run the following commands:
git clone http://github.com/symfony/symfony-standard.git cd symfony-standard rm -rf .git
Once you've downloaded the standard edition, installation is easy, and basically involves making sure your system is ready for Symfony.
Before you begin, make sure that your local system is properly configured for Symfony. To do this, execute the following:
php app/check.php
If you get any warnings or recommendations, fix these now before moving on.
If you downloaded the archive "without vendors" or installed via git, then you need to download all of the necessary vendor libraries. If you're not sure if you need to do this, check to see if you have a vendor/
directory. If you don't, or if that directory is empty, run the following:
php bin/vendors install
Note that you must have git installed and be able to execute the git
command to execute this script. If you don't have git available, either install it or download Symfony with the vendor libraries already included.
Congratulations! You're now ready to use Symfony. If you've unzipped Symfony in the web root of your computer, then you should be able to access the web version of the Symfony requirements check via:
http://localhost/Symfony/web/config.php
If everything looks good, click the "Bypass configuration and go to the Welcome page" link to load up your first Symfony page.
You can also use a web-based configurator by clicking on the "Configure your
Symfony Application online" link of the config.php
page.
To see a real-live Symfony page in action, access the following page:
web/app_dev.php/demo/hello/Fabien
This distribution is meant to be the starting point for your application, but it also contains some sample code that you can learn from and play with.
A great way to start learning Symfony is via the Quick Tour, which will take you through all the basic features of Symfony2 and the test pages that are available in the standard edition.
Once you're feeling good, you can move onto reading the official Symfony2 book.
Since the standard edition is fully-configured and comes with some examples, you'll need to make a few changes before using it to build your application.
The distribution is configured with the following defaults:
A default bundle, AcmeDemoBundle
, shows you Symfony2 in action. After playing with it, you can remove it by following these steps:
src/Acme
directory;app/config/routing_dev.yml
;app/AppKernel.php
;The Symfony Standard Edition comes pre-configured with the following bundles:
Enjoy!


×
Signature Info
Gene
Sign
×
Genes Used for Projection
FastProject Viewer
PCA Before Project?
Filter Level
+Show Genes
Signature Score Colors:
Value
Rank
⇩Export


Lorem ipsum
Every member who works hard to learn the beats and choreography will have a chance to perform.


My-home
Relsate
Registration
Contact
Registration
FirstName:
LastName:
Gender:
Male
Female
Age:
Under 20
between 30-50
Under 20
Address:
ComanyName:
Email:
PhoneNumber:
Select Code
250
251
255
277
279
280
281
279
Commeents:


A collection of Animation (?) objects, used to change default animations. A value of false will disable all animations in the widget.


Public Member Functions | |
Destructor | |
| virtual | ~DOMLSInput () |
| Destructor. | |
Functions introduced in DOM Level 3 | |
| virtual const XMLCh * | getStringData () const =0 |
| String data to parse. | |
| virtual InputSource * | getByteStream () const =0 |
| Returns the byte stream for this input source. | |
| virtual const XMLCh * | getEncoding () const =0 |
| An input source can be set to force the parser to assume a particular encoding for the data that input source reprsents, via the setEncoding() method. | |
| virtual const XMLCh * | getPublicId () const =0 |
| Get the public identifier for this input source. | |
| virtual const XMLCh * | getSystemId () const =0 |
| Get the system identifier for this input source. | |
| virtual const XMLCh * | getBaseURI () const =0 |
| Get the base URI to be used for resolving relative URIs to absolute URIs. | |
| virtual void | setStringData (const XMLCh *data)=0 |
| Sets the UTF-16 string for this input source. | |
| virtual void | setByteStream (InputSource *stream)=0 |
| Sets the byte stream for this input source. | |
| virtual void | setEncoding (const XMLCh *const encodingStr)=0 |
| Set the encoding which will be required for use with the XML text read via a stream opened by this input source. | |
| virtual void | setPublicId (const XMLCh *const publicId)=0 |
| Set the public identifier for this input source. | |
| virtual void | setSystemId (const XMLCh *const systemId)=0 |
| Set the system identifier for this input source. | |
| virtual void | setBaseURI (const XMLCh *const baseURI)=0 |
| Set the base URI to be used for resolving relative URIs to absolute URIs. | |
Non-standard Extension | |
| virtual void | setIssueFatalErrorIfNotFound (bool flag)=0 |
| Indicates if the parser should issue fatal error if this input source is not found. | |
| virtual bool | getIssueFatalErrorIfNotFound () const =0 |
| Get the flag that indicates if the parser should issue fatal error if this input source is not found. | |
| virtual void | release ()=0 |
| Called to indicate that this DOMLSInput is no longer in use and that the implementation may relinquish any resources associated with it. | |
Protected Member Functions | |
Hidden constructors | |
| DOMLSInput () |
This interface allows an application to encapsulate information about an input source in a single object, which may include a public identifier, a system identifier, a byte stream (possibly with a specified encoding), and/or a character stream.
There are two places that the application will deliver this input source to the parser: as the argument to the parse method, or as the return value of the DOMLSResourceResolver.resolveResource method.
The DOMLSParser will use the DOMLSInput object to determine how to read XML input. If there is a character stream available, the parser will read that stream directly; if not, the parser will use a byte stream, if available; if neither a character stream nor a byte stream is available, the parser will attempt to open a URI connection to the resource identified by the system identifier.
A DOMLSInput object belongs to the application: the parser shall never modify it in any way (it may modify a copy if necessary).
| DOMLSInput::DOMLSInput | ( | ) | [protected] |
| virtual DOMLSInput::~DOMLSInput | ( | ) | [virtual] |
Destructor.
| virtual const XMLCh* DOMLSInput::getStringData | ( | ) | const [pure virtual] |
String data to parse.
If provided, this will always be treated as a sequence of 16-bit units (UTF-16 encoded characters). It is not a requirement to have an XML declaration when using stringData. If an XML declaration is present, the value of the encoding attribute will be ignored.
Implemented in Wrapper4InputSource.
| virtual InputSource* DOMLSInput::getByteStream | ( | ) | const [pure virtual] |
Returns the byte stream for this input source.
Implemented in Wrapper4InputSource.
| virtual const XMLCh* DOMLSInput::getEncoding | ( | ) | const [pure virtual] |
An input source can be set to force the parser to assume a particular encoding for the data that input source reprsents, via the setEncoding() method.
This method returns name of the encoding that is to be forced. If the encoding has never been forced, it returns a null pointer.
Implemented in Wrapper4InputSource.
| virtual const XMLCh* DOMLSInput::getPublicId | ( | ) | const [pure virtual] |
Get the public identifier for this input source.
Implemented in Wrapper4InputSource.
| virtual const XMLCh* DOMLSInput::getSystemId | ( | ) | const [pure virtual] |
Get the system identifier for this input source.
If the system ID is a URL, it will be fully resolved.
Implemented in Wrapper4InputSource.
| virtual const XMLCh* DOMLSInput::getBaseURI | ( | ) | const [pure virtual] |
Get the base URI to be used for resolving relative URIs to absolute URIs.
If the baseURI is itself a relative URI, the behavior is implementation dependent.
Implemented in Wrapper4InputSource.
| virtual void DOMLSInput::setStringData | ( | const XMLCh * | data | ) | [pure virtual] |
| virtual void DOMLSInput::setByteStream | ( | InputSource * | stream | ) | [pure virtual] |
Sets the byte stream for this input source.
Implemented in Wrapper4InputSource.
| virtual void DOMLSInput::setEncoding | ( | const XMLCh *const | encodingStr | ) | [pure virtual] |
Set the encoding which will be required for use with the XML text read via a stream opened by this input source.
This is usually not set, allowing the encoding to be sensed in the usual XML way. However, in some cases, the encoding in the file is known to be incorrect because of intermediate transcoding, for instance encapsulation within a MIME document.
| encodingStr | The name of the encoding to force. |
Implemented in Wrapper4InputSource.
| virtual void DOMLSInput::setPublicId | ( | const XMLCh *const | publicId | ) | [pure virtual] |
Set the public identifier for this input source.
The public identifier is always optional: if the application writer includes one, it will be provided as part of the location information.
| publicId | The public identifier as a string. |
Implemented in Wrapper4InputSource.
| virtual void DOMLSInput::setSystemId | ( | const XMLCh *const | systemId | ) | [pure virtual] |
Set the system identifier for this input source.
The system id is always required. The public id may be used to map to another system id, but the system id must always be present as a fall back.
If the system ID is a URL, it must be fully resolved.
| systemId | The system identifier as a string. |
Implemented in Wrapper4InputSource.
| virtual void DOMLSInput::setBaseURI | ( | const XMLCh *const | baseURI | ) | [pure virtual] |
Set the base URI to be used for resolving relative URIs to absolute URIs.
If the baseURI is itself a relative URI, the behavior is implementation dependent.
| baseURI | The base URI. |
Implemented in Wrapper4InputSource.
| virtual void DOMLSInput::setIssueFatalErrorIfNotFound | ( | bool | flag | ) | [pure virtual] |
Indicates if the parser should issue fatal error if this input source is not found.
If set to false, the parser issue warning message instead.
| flag | True if the parser should issue fatal error if this input source is not found. If set to false, the parser issue warning message instead. (Default: true) |
Implemented in Wrapper4InputSource.
| virtual bool DOMLSInput::getIssueFatalErrorIfNotFound | ( | ) | const [pure virtual] |
Get the flag that indicates if the parser should issue fatal error if this input source is not found.
Implemented in Wrapper4InputSource.
| virtual void DOMLSInput::release | ( | ) | [pure virtual] |
Called to indicate that this DOMLSInput is no longer in use and that the implementation may relinquish any resources associated with it.
Access to a released object will lead to unexpected result.
Implemented in Wrapper4InputSource.


Launched in 2020, A1uniformsvn.com is the leading platform for global wholesale trade. We serve millions of buyers and suppliers around the world.
We do this by giving suppliers the tools necessary to reach a global audience for their products, and by helping buyers find products and suppliers quickly and efficiently.
Shopping A1uniformsvn.com brings you hundreds of millions of products in over 40 different major categories, including consumer electronics, clothes, machinery and apparel.
Buyers for these products are located in 190+ countries and regions, and exchange hundreds of thousands of messages with suppliers on the platform each day.
As a platform, we continue to develop services to help businesses do more and discover new opportunities.
Whether it’s sourcing from your mobile phone or contacting suppliers in their local language, turn to Exshop.com for all your global business needs.
CEO & Founder
<EMAIL_ADDRESS>Art Director
<EMAIL_ADDRESS>Designer
anhtran@gmail.com


{{site.user_description}}
{{site.user_expertise}}
Python for Data and React for some personal projects
Git is a classic version-control system, Docker to virtualize my applications and PyCharm my favorite IDE
AWS for my cloud services and GitHub to host my projects


WebApp Login Page
Email Address
Email is required.
Invalid email address.
Password
Password is required.
Password must be atleast 8 characters
Sign Up
Sign In


Extension of the AAX_CEffectParameters class for monolithic VIs and effects.
This extension to AAX_CEffectParameters adds some conveniences for Virtual Instrument (VI) plug-ins and for other plug-ins that use a monolithic processing object, i.e. an object that combines state data with the audio render routine in a single object.
- The RenderAudio method provides a direct audio processing callback within the data model object. Perform all audio processing in this method.
- The StaticDescribe method establishes a generic MIDI processing context for the Effect. Call this method from the plug-in's Description callback implementation.
- The AddSynchronizedParameter method provides a mechanism for synchronizing parameter updates with the real-time thread, allowing deterministic, accurate automation playback. For more information abou this feature, see Fixing timing issues due to shared data
- Note
- This convenience class assumes a monolithic processing environment (i.e. AAX_eConstraintLocationMask_DataModel .) This precludes the use of AAX_CMonolithicParameters -derived Effects in distributed-processing formats such as AAX DSP.
AAX_CMonolithicParameters


PsychoPy is an open-source package for running experiments in Python (a real and free alternative to Matlab). PsychoPy combines the graphical strengths of OpenGL with the easy Python syntax to give scientists a free and simple stimulus presentation and control package. It is used by many labs worldwide for psychophysics, cognitive neuroscience and experimental psychology.
Because it’s open source, you can download it and modify the package if you don’t like it. And if you make changes that others might use then please consider giving them back to the community via the mailing list. PsychoPy has been written and provided to you absolutely for free. For it to get better it needs as much input from everyone as possible.
There are many advantages to using PsychoPy, but here are some of the key ones
Simple install process
Precise timing
- Huge variety of stimuli (see screenshots) generated in real-time:
- linear gratings, bitmaps constantly updating
- radial gratings
- random dots
- movies (DivX, mov, mpg...)
- text (unicode in any truetype font)
- shapes
- sounds (tones, numpy arrays, wav, ogg...)
Platform independent - run the same script on Win, macOS or Linux
Flexible stimulus units (degrees, cm, or pixels)
Coder interface for those that like to program
Builder interface for those that don’t
Input from keyboard, mouse, microphone or button boxes
Multi-monitor support
Automated monitor calibration (for supported photometers)
Although PsychoPy runs on a wide variety of hardware, and on Windows, macOS or Linux, it really does benefit from a decent graphics card. Get an ATI or nVidia card that supports OpenGL 2.0. Avoid built-in Intel graphics chips (e.g. GMA 950)


001 package org.apache.archiva.consumers; 002 003 /* 004 * Licensed to the Apache Software Foundation (ASF) under one 005 * or more contributor license agreements. See the NOTICE file 006 * distributed with this work for additional information 007 * regarding copyright ownership. The ASF licenses this file 008 * to you under the Apache License, Version 2.0 (the 009 * "License"); you may not use this file except in compliance 010 * with the License. You may obtain a copy of the License at 011 * 012 * http://www.apache.org/licenses/LICENSE-2.0 013 * 014 * Unless required by applicable law or agreed to in writing, 015 * software distributed under the License is distributed on an 016 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 017 * KIND, either express or implied. See the License for the 018 * specific language governing permissions and limitations 019 * under the License. 020 */ 021 022 import org.apache.archiva.admin.model.beans.ManagedRepository; 023 024 import java.util.Date; 025 import java.util.List; 026 027 /** 028 * A consumer of content (files) in the repository. 029 * 030 * olamy: TODO/FIXME we must review this api, in the current situation we use prototype beans rather than singletons 031 * this is a bit memory consuming the better will be to ConsumerContext bean to transport repository context etc... 032 */ 033 public interface RepositoryContentConsumer 034 extends Consumer 035 { 036 /** 037 * Get the list of included file patterns for this consumer. 038 * 039 * @return the list of {@link String} patterns. (example: "**/*.pom") 040 */ 041 List<String> getIncludes(); 042 043 /** 044 * Get the list of excluded file patterns for this consumer. 045 * 046 * @return the list of {@link String} patterns. (example: "**/*.pom") - (can be null for no exclusions) 047 */ 048 List<String> getExcludes(); 049 050 /** 051 *
 052 * Event that triggers at the beginning of a scan. 053 *
 054 *
 055 *
 056 * NOTE: This would be a good place to initialize the consumer, to lock any resources, and to 057 * generally start tracking the scan as a whole. 058 *
 059 * 060 * @param repository the repository that this consumer is being used for. 061 * @param whenGathered the start of the repository scan 062 * @throws ConsumerException if there was a problem with using the provided repository with the consumer. 063 */ 064 void beginScan( ManagedRepository repository, Date whenGathered ) 065 throws ConsumerException; 066 067 /** 068 *
 069 * Event that triggers at the beginning of a scan, where you can also indicate whether the consumers will be 070 * executed on an entire repository or on a specific resource. 071 *
 072 * 073 * @param repository the repository that this consumer is being used for. 074 * @param whenGathered the start of the repository scan 075 * @param executeOnEntireRepo flags whether the consumer will be executed on an entire repository or just on a specific resource 076 * @throws ConsumerException if there was a problem with using the provided repository with the consumer. 077 * @see RepositoryContentConsumer#beginScan(ManagedRepository, java.util.Date) 078 */ 079 void beginScan( ManagedRepository repository, Date whenGathered, boolean executeOnEntireRepo ) 080 throws ConsumerException; 081 082 /** 083 *
 084 * Event indicating a file is to be processed by this consumer. 085 *
 086 *
 087 *
 088 * NOTE: The consumer does not need to process the file immediately, can can opt to queue and/or track 089 * the files to be processed in batch. Just be sure to complete the processing by the {@link #completeScan()} 090 * event. 091 *
 092 * 093 * @param path the relative file path (in the repository) to process. 094 * @throws ConsumerException if there was a problem processing this file. 095 */ 096 void processFile( String path ) 097 throws ConsumerException; 098 099 /** 100 * @param path 101 * @param executeOnEntireRepo 102 * @throws Exception 103 */ 104 void processFile( String path, boolean executeOnEntireRepo ) 105 throws Exception; 106 107 /** 108 *
 109 * Event that triggers on the completion of a scan. 110 *
 111 *
 112 *
 113 * NOTE: If the consumer opted to batch up processing requests in the {@link #processFile(String)} event 114 * this would be the last opportunity to drain any processing queue's. 115 *
 116 */ 117 void completeScan(); 118 119 /** 120 * @param executeOnEntireRepo 121 * @throws Exception 122 */ 123 void completeScan( boolean executeOnEntireRepo ); 124 125 /** 126 * Whether the consumer should process files that have not been modified since the time passed in to the scan 127 * method. 128 * 129 * @return whether to process the unmodified files 130 */ 131 boolean isProcessUnmodified(); 132 }


#include <tensor.h>
Represents an n-dimensional array of values.
Constructors and Destructors |
|
|---|---|
Tensor()
Creates a 1-dimensional, 0-element float tensor.
|
|
Tensor(DataType type, const TensorShape & shape)
|
|
Tensor(Allocator *a, DataType type, const TensorShape & shape)
Creates a tensor with the input
type and shape , using the allocator a to allocate the underlying buffer. |
|
Tensor(Allocator *a, DataType type, const TensorShape & shape, const AllocationAttributes & allocation_attr)
Creates a tensor with the input
type and shape , using the allocator a and the specified "allocation_attr" to allocate the underlying buffer. |
|
Tensor(DataType type)
Creates an empty Tensor of the given data type.
|
|
Tensor(const Tensor & other)
Copy constructor.
|
|
Tensor(Tensor && other)
Move constructor.
|
|
~Tensor()
|
Public functions |
|
|---|---|
AllocatedBytes() const
|
size_t
|
AsProtoField(TensorProto *proto) const
|
void
Fills in
proto with *this tensor's content. |
AsProtoTensorContent(TensorProto *proto) const
|
void
|
CopyFrom(const Tensor & other, const TensorShape & shape) TF_MUST_USE_RESULT
|
bool
Copy the other tensor into this tensor and reshape it.
|
DebugString() const
|
string
A human-readable summary of the tensor suitable for debugging.
|
FillDescription(TensorDescription *description) const
|
void
Fill in the
TensorDescription proto with metadata about the tensor that is useful for monitoring and debugging. |
FromProto(const TensorProto & other) TF_MUST_USE_RESULT
|
bool
Parse
other and construct the tensor. |
FromProto(Allocator *a, const TensorProto & other) TF_MUST_USE_RESULT
|
bool
|
IsAligned() const
|
bool
Returns true iff this tensor is aligned.
|
IsInitialized() const
|
bool
If necessary, has this Tensor been initialized?
|
IsSameSize(const Tensor & b) const
|
bool
|
NumElements() const
|
int64
Convenience accessor for the tensor shape.
|
SharesBufferWith(const Tensor & b) const
|
bool
|
Slice(int64 dim0_start, int64 dim0_limit) const
|
Slice this tensor along the 1st dimension.
|
SubSlice(int64 index) const
|
Select a subslice from this tensor along the 1st dimension.
|
SummarizeValue(int64 max_entries, bool print_v2) const
|
string
Render the first
max_entries values in *this into a string. |
TotalBytes() const
|
size_t
Returns the estimated memory usage of this tensor.
|
UnsafeCopyFromInternal(const Tensor &, DataType dtype, const TensorShape &)
|
void
Copy the other tensor into this tensor and reshape it and reinterpret the buffer's datatype.
|
bit_casted_shaped(gtl::ArraySlice< int64 > new_sizes)
|
TTypes< T, NDIMS >::Tensor
Return the tensor data to an
Eigen::Tensor with the new shape specified in new_sizes and cast to a new dtype T . |
bit_casted_shaped(gtl::ArraySlice< int64 > new_sizes) const
|
TTypes< T, NDIMS >::ConstTensor
Return the tensor data to an
Eigen::Tensor with the new shape specified in new_sizes and cast to a new dtype T . |
bit_casted_tensor()
|
TTypes< T, NDIMS >::Tensor
Return the tensor data to an
Eigen::Tensor with the same size but a bitwise cast to the specified dtype T . |
bit_casted_tensor() const
|
TTypes< T, NDIMS >::ConstTensor
Return the tensor data to an
Eigen::Tensor with the same size but a bitwise cast to the specified dtype T . |
dim_size(int d) const
|
int64
Convenience accessor for the tensor shape.
|
dims() const
|
int
Convenience accessor for the tensor shape.
|
dtype() const
|
DataType
Returns the data type.
|
flat()
|
TTypes< T >::Flat
Return the tensor data as an
Eigen::Tensor of the data type and a specified shape. |
flat() const
|
TTypes< T >::ConstFlat
|
flat_inner_dims()
|
TTypes< T, NDIMS >::Tensor
Returns the data as an Eigen::Tensor with NDIMS dimensions, collapsing all Tensor dimensions but the last NDIMS-1 into the first dimension of the result.
|
flat_inner_dims() const
|
TTypes< T, NDIMS >::ConstTensor
|
flat_inner_outer_dims(int64 begin)
|
TTypes< T, NDIMS >::Tensor
|
flat_inner_outer_dims(int64 begin) const
|
TTypes< T, NDIMS >::ConstTensor
|
flat_outer_dims()
|
TTypes< T, NDIMS >::Tensor
Returns the data as an Eigen::Tensor with NDIMS dimensions, collapsing all Tensor dimensions but the first NDIMS-1 into the last dimension of the result.
|
flat_outer_dims() const
|
TTypes< T, NDIMS >::ConstTensor
|
matrix()
|
TTypes< T >::Matrix
|
matrix() const
|
TTypes< T >::ConstMatrix
|
operator=(const Tensor & other)
|
Tensor &
Assign operator. This tensor shares other's underlying storage.
|
operator=(Tensor && other)
|
Tensor &
Move operator. See move constructor for details.
|
reinterpret_last_dimension()
|
TTypes< T, NDIMS >::Tensor
Return the tensor data to an
Eigen::Tensor with the last dimension elements converted into single elements of a larger type. |
reinterpret_last_dimension() const
|
TTypes< T, NDIMS >::ConstTensor
Return the tensor data to an
Eigen::Tensor with the last dimension elements converted into single elements of a larger type. |
scalar()
|
TTypes< T >::Scalar
|
scalar() const
|
TTypes< T >::ConstScalar
|
shape() const
|
const TensorShape &
Returns the shape of the tensor.
|
shaped(gtl::ArraySlice< int64 > new_sizes)
|
TTypes< T, NDIMS >::Tensor
|
shaped(gtl::ArraySlice< int64 > new_sizes) const
|
TTypes< T, NDIMS >::ConstTensor
|
tensor()
|
TTypes< T, NDIMS >::Tensor
|
tensor() const
|
TTypes< T, NDIMS >::ConstTensor
|
tensor_data() const
|
StringPiece
Returns a
StringPiece mapping the current tensor's buffer. |
unaligned_flat()
|
TTypes< T >::UnalignedFlat
|
unaligned_flat() const
|
TTypes< T >::UnalignedConstFlat
|
unaligned_shaped(gtl::ArraySlice< int64 > new_sizes)
|
TTypes< T, NDIMS >::UnalignedTensor
|
unaligned_shaped(gtl::ArraySlice< int64 > new_sizes) const
|
TTypes< T, NDIMS >::UnalignedConstTensor
|
vec()
|
TTypes< T >::Vec
Return the tensor data as an
Eigen::Tensor with the type and sizes of this Tensor . |
vec() const
|
TTypes< T >::ConstVec
Const versions of all the methods above.
|
size_t AllocatedBytes() const
void AsProtoField( TensorProto *proto ) const
Fills in proto
with *this
tensor's content.
AsProtoField()
fills in the repeated field for proto.dtype()
, while AsProtoTensorContent()
encodes the content in proto.tensor_content()
in a compact form.
void AsProtoTensorContent( TensorProto *proto ) const
bool CopyFrom( const Tensor & other, const TensorShape & shape ) TF_MUST_USE_RESULT
Copy the other tensor into this tensor and reshape it.
This tensor shares other's underlying storage. Returns true
iff other.shape()
has the same number of elements of the given shape
.
string DebugString() const
A human-readable summary of the tensor suitable for debugging.
void FillDescription( TensorDescription *description ) const
Fill in the TensorDescription
proto with metadata about the tensor that is useful for monitoring and debugging.
bool FromProto( const TensorProto & other ) TF_MUST_USE_RESULT
Parse other
and construct the tensor.
Returns true
iff the parsing succeeds. If the parsing fails, the state of *this
is unchanged.
bool FromProto( Allocator *a, const TensorProto & other ) TF_MUST_USE_RESULT
bool IsAligned() const
Returns true iff this tensor is aligned.
bool IsInitialized() const
If necessary, has this Tensor been initialized?
Zero-element Tensors are always considered initialized, even if they have never been assigned to and do not have any memory allocated.
bool IsSameSize( const Tensor & b ) const
int64 NumElements() const
Convenience accessor for the tensor shape.
bool SharesBufferWith( const Tensor & b ) const
Tensor Slice( int64 dim0_start, int64 dim0_limit ) const
Slice this tensor along the 1st dimension.
I.e., the returned tensor satisfies returned[i, ...] == this[dim0_start + i, ...]. The returned tensor shares the underlying tensor buffer with this tensor.
NOTE: The returned tensor may not satisfy the same alignment requirement as this tensor depending on the shape. The caller must check the returned tensor's alignment before calling certain methods that have alignment requirement (e.g., flat()
, tensor()
).
NOTE: When fed with an N-dimensional tensor, this method returns a tensor also with N dimensions. If you want to select a sub tensor, see SubSlice.
REQUIRES: dims()
>= 1 REQUIRES: 0 <= dim0_start <= dim0_limit <= dim_size(0)
Tensor SubSlice( int64 index ) const
Select a subslice from this tensor along the 1st dimension.
When fed with an N-dimensional tensor, this method returns a tensor with N-1 dimensions, where the returned tensor is a subslice of the input tensor along the first dimension. The N-1 dimensions of the returned tensor are the last N-1 dimensions of the input tensor.
NOTE: The returned tensor may not satisfy the same alignment requirement as this tensor depending on the shape. The caller must check the returned tensor's alignment before calling certain methods that have alignment requirement (e.g., flat()
, tensor()
).
REQUIRES: dims()
>= 1 REQUIRES: 0 <= dim0_start < dim_size(0)
string SummarizeValue( int64 max_entries, bool print_v2 ) const
Render the first max_entries
values in *this
into a string.
Tensor()
Creates a 1-dimensional, 0-element float tensor.
The returned Tensor is not a scalar (shape {}), but is instead an empty one-dimensional Tensor (shape {0}, NumElements() == 0). Since it has no elements, it does not need to be assigned a value and is initialized by default (IsInitialized() is true). If this is undesirable, consider creating a one-element scalar which does require initialization:
Tensor(DT_FLOAT, TensorShape({}))
Tensor( DataType type, const TensorShape & shape )
Creates a Tensor of the given type
and shape
.
If LogMemory::IsEnabled() the allocation is logged as coming from an unknown kernel and step. Calling the Tensor constructor directly from within an Op is deprecated: use the OpKernelConstruction/OpKernelContext allocate_* methods to allocate a new tensor, which record the kernel and step.
The underlying buffer is allocated using a CPUAllocator
.
Tensor( Allocator *a, DataType type, const TensorShape & shape )
Creates a tensor with the input type
and shape
, using the allocator a
to allocate the underlying buffer.
If LogMemory::IsEnabled() the allocation is logged as coming from an unknown kernel and step. Calling the Tensor constructor directly from within an Op is deprecated: use the OpKernelConstruction/OpKernelContext allocate_* methods to allocate a new tensor, which record the kernel and step.
a
must outlive the lifetime of this Tensor.
Tensor( Allocator *a, DataType type, const TensorShape & shape, const AllocationAttributes & allocation_attr )
Creates a tensor with the input type
and shape
, using the allocator a
and the specified "allocation_attr" to allocate the underlying buffer.
If the kernel and step are known allocation_attr.allocation_will_be_logged should be set to true and LogMemory::RecordTensorAllocation should be called after the tensor is constructed. Calling the Tensor constructor directly from within an Op is deprecated: use the OpKernelConstruction/OpKernelContext allocate_* methods to allocate a new tensor, which record the kernel and step.
a
must outlive the lifetime of this Tensor.
Tensor( DataType type )
Creates an empty Tensor of the given data type.
Like Tensor(), returns a 1-dimensional, 0-element Tensor with IsInitialized() returning True. See the Tensor() documentation for details.
Tensor( Tensor && other )
Move constructor.
After this call,
size_t TotalBytes() const
Returns the estimated memory usage of this tensor.
void UnsafeCopyFromInternal( const Tensor &, DataType dtype, const TensorShape & )
Copy the other tensor into this tensor and reshape it and reinterpret the buffer's datatype.
This tensor shares other's underlying storage.
TTypes< T, NDIMS >::Tensor bit_casted_shaped( gtl::ArraySlice< int64 > new_sizes )
Return the tensor data to an Eigen::Tensor
with the new shape specified in new_sizes
and cast to a new dtype T
.
Using a bitcast is useful for move and copy operations. The allowed bitcast is the only difference from shaped()
.
TTypes< T, NDIMS >::ConstTensor bit_casted_shaped( gtl::ArraySlice< int64 > new_sizes ) const
Return the tensor data to an Eigen::Tensor
with the new shape specified in new_sizes
and cast to a new dtype T
.
Using a bitcast is useful for move and copy operations. The allowed bitcast is the only difference from shaped()
.
TTypes< T, NDIMS >::Tensor bit_casted_tensor()
Return the tensor data to an Eigen::Tensor
with the same size but a bitwise cast to the specified dtype T
.
Using a bitcast is useful for move and copy operations. NOTE: this is the same as tensor()
except a bitcast is allowed.
TTypes< T, NDIMS >::ConstTensor bit_casted_tensor() const
Return the tensor data to an Eigen::Tensor
with the same size but a bitwise cast to the specified dtype T
.
Using a bitcast is useful for move and copy operations. NOTE: this is the same as tensor()
except a bitcast is allowed.
int64 dim_size( int d ) const
Convenience accessor for the tensor shape.
int dims() const
Convenience accessor for the tensor shape.
For all shape accessors, see comments for relevant methods of TensorShape
in tensor_shape.h
.
DataType dtype() const
Returns the data type.
TTypes< T >::Flat flat()
Return the tensor data as an Eigen::Tensor
of the data type and a specified shape.
These methods allow you to access the data with the dimensions and sizes of your choice. You do not need to know the number of dimensions of the Tensor to call them. However, they CHECK
that the type matches and the dimensions requested creates an Eigen::Tensor
with the same number of elements as the tensor.
Example:
typedef float T; Tensor my_ten(...built with Shape{planes: 4, rows: 3, cols: 5}...); // 1D Eigen::Tensor, size 60: auto flat = my_ten.flat(); // 2D Eigen::Tensor 12 x 5: auto inner = my_ten.flat_inner_dims (); // 2D Eigen::Tensor 4 x 15: auto outer = my_ten.shaped ({4, 15}); // CHECK fails, bad num elements: auto outer = my_ten.shaped ({4, 8}); // 3D Eigen::Tensor 6 x 5 x 2: auto weird = my_ten.shaped ({6, 5, 2}); // CHECK fails, type mismatch: auto bad = my_ten.flat ();
TTypes< T >::ConstFlat flat() const
TTypes< T, NDIMS >::Tensor flat_inner_dims()
TTypes< T, NDIMS >::ConstTensor flat_inner_dims() const
TTypes< T, NDIMS >::Tensor flat_inner_outer_dims( int64 begin )
Returns the data as an Eigen::Tensor with NDIMS dimensions, collapsing the first 'begin' Tensor dimensions into the first dimension of the result and the Tensor dimensions of the last dims() - 'begin' - NDIMS into the last dimension of the result.
If 'begin' < 0 then the |'begin'| leading dimensions of size 1 will be added. If 'begin' + NDIMS > dims() then 'begin' + NDIMS - dims() trailing dimensions of size 1 will be added.
TTypes< T, NDIMS >::ConstTensor flat_inner_outer_dims( int64 begin ) const
TTypes< T, NDIMS >::Tensor flat_outer_dims()
TTypes< T, NDIMS >::ConstTensor flat_outer_dims() const
TTypes< T >::Matrix matrix()
TTypes< T >::ConstMatrix matrix() const
Tensor & operator=( const Tensor & other )
Assign operator. This tensor shares other's underlying storage.
TTypes< T, NDIMS >::Tensor reinterpret_last_dimension()
Return the tensor data to an Eigen::Tensor
with the last dimension elements converted into single elements of a larger type.
For example, this is useful for kernels that can treat NCHW_VECT_C int8 tensors as NCHW int32 tensors. The sizeof(T) should equal the size of the original element type * num elements in the original last dimension. NDIMS should be 1 less than the original number of dimensions.
TTypes< T, NDIMS >::ConstTensor reinterpret_last_dimension() const
Return the tensor data to an Eigen::Tensor
with the last dimension elements converted into single elements of a larger type.
For example, this is useful for kernels that can treat NCHW_VECT_C int8 tensors as NCHW int32 tensors. The sizeof(T) should equal the size of the original element type * num elements in the original last dimension. NDIMS should be 1 less than the original number of dimensions.
TTypes< T >::Scalar scalar()
TTypes< T >::ConstScalar scalar() const
const TensorShape & shape() const
Returns the shape of the tensor.
TTypes< T, NDIMS >::Tensor shaped( gtl::ArraySlice< int64 > new_sizes )
TTypes< T, NDIMS >::ConstTensor shaped( gtl::ArraySlice< int64 > new_sizes ) const
TTypes< T, NDIMS >::Tensor tensor()
TTypes< T, NDIMS >::ConstTensor tensor() const
StringPiece tensor_data() const
Returns a StringPiece
mapping the current tensor's buffer.
The returned StringPiece
may point to memory location on devices that the CPU cannot address directly.
NOTE: The underlying tensor buffer is refcounted, so the lifetime of the contents mapped by the StringPiece
matches the lifetime of the buffer; callers should arrange to make sure the buffer does not get destroyed while the StringPiece
is still used.
REQUIRES: DataTypeCanUseMemcpy(dtype())
.
TTypes< T >::UnalignedFlat unaligned_flat()
TTypes< T >::UnalignedConstFlat unaligned_flat() const
TTypes< T, NDIMS >::UnalignedTensor unaligned_shaped( gtl::ArraySlice< int64 > new_sizes )
TTypes< T, NDIMS >::UnalignedConstTensor unaligned_shaped( gtl::ArraySlice< int64 > new_sizes ) const
TTypes< T >::Vec vec()
Return the tensor data as an Eigen::Tensor
with the type and sizes of this Tensor
.
Use these methods when you know the data type and the number of dimensions of the Tensor and you want an Eigen::Tensor
automatically sized to the Tensor
sizes. The implementation check fails if either type or sizes mismatch.
Example:
typedef float T; Tensor my_mat(...built with Shape{rows: 3, cols: 5}...); auto mat = my_mat.matrix(); // 2D Eigen::Tensor, 3 x 5. auto mat = my_mat.tensor (); // 2D Eigen::Tensor, 3 x 5. auto vec = my_mat.vec (); // CHECK fails as my_mat is 2D. auto vec = my_mat.tensor (); // CHECK fails as my_mat is 2D. auto mat = my_mat.matrix ();// CHECK fails as type mismatch.
TTypes< T >::ConstVec vec() const
Const versions of all the methods above.
~Tensor()


Module: Zif::Layers::Tileable
- Included in:
- ActiveBitmaskedTiledLayer, ActiveTiledLayer, BitmaskedTiledLayer, TiledLayer
- Defined in:
- lib/zif/layers/tileable.rb
Overview
Functionality shared between TiledLayer & BitmaskedTiledLayer
Modifies the layer to be based around the concept of a “logical” position. This is used to differentiate between the “natural” x, y position on the screen. The “logical” position is instead the natural position divided by the tile size, and is used to index the sprites array.
For performance reasons, the sprites array is still implemented as one-dimensional array, but the idea is that it could have been implemented as a two-dimensional array of rows (logical_x
) and columns (logical_y
).
Add sprites to the layer using #add_positioned_sprite which sets the logical position on the sprite.
Instance Method Summary collapse
-
#add_positioned_sprite(sprite:, logical_x:, logical_y:) ⇒ Object
Overrides SimpleLayer#add_positioned_sprite or ActiveLayer#add_positioned_sprite Adds
sprite
to the @sprites array at the position indicated bylogical_x
andlogical_y
. - #exclude_from_serialize ⇒ Object
-
#intersecting_sprites(left:, bottom:, right:, top:) ⇒ Object
Overrides Layerable#intersecting_sprites A convenience to calling #visible_sprites with boundary values instead of a [x,y,w,h] rect.
-
#reinitialize_sprites ⇒ Object
Overrides SimpleLayer#reinitialize_sprites or ActiveLayer#reinitialize_sprites Clears the @sprites array, based on the logical_height and logical_width of the LayerGroup.
-
#remove_positioned_sprite(sprite) ⇒ Object
Overrides Layerable#remove_positioned_sprite Remove a sprite which has already been added.
-
#remove_tile(logical_x, logical_y) ⇒ Object
Clears the element in the @sprites array indicated by the logical position.
-
#tile(logical_x, logical_y) ⇒ Zif::Sprite
Uses #tile_pos_to_sprite_index and returns the sprite at that position in @sprites.
-
#tile_pos_to_sprite_index(logical_x, logical_y) ⇒ Integer
Convert logical_x and logical_y to the index of the sprite in the @sprites array.
-
#visible_sprites(given_rect = nil) ⇒ Enumerator
Overrides Layerable#visible_sprites This returns an enumerator which can be used to iterate over only the tiles which are visible.
Instance Method Details
#add_positioned_sprite(sprite:, logical_x:, logical_y:) ⇒ Object
Overrides SimpleLayer#add_positioned_sprite or ActiveLayer#add_positioned_sprite Adds sprite
to the @sprites array at the position indicated by logical_x
and logical_y
. Ensures the logical position is saved on the sprite
.
40 41 42 43 44 45 46 47 48 |
# File 'lib/zif/layers/tileable.rb', line 40 def add_positioned_sprite(sprite:, logical_x:, logical_y:) # puts "#{@layer_name}: Tileable#add_positioned_sprite #{logical_x} #{logical_y}" # puts<EMAIL_ADDRESS>@sprites[tile_pos_to_sprite_index(logical_x, logical_y)] = position_sprite( sprite: sprite, logical_x: logical_x, logical_y: logical_y ) end |
#exclude_from_serialize ⇒ Object
133 134 135 |
# File 'lib/zif/layers/tileable.rb', line 133 def exclude_from_serialize %w[sprites primitives] end |
#intersecting_sprites(left:, bottom:, right:, top:) ⇒ Object
Overrides Layerable#intersecting_sprites A convenience to calling #visible_sprites with boundary values instead of a [x,y,w,h] rect.
129 130 131 |
# File 'lib/zif/layers/tileable.rb', line 129 def intersecting_sprites(left:, bottom:, right:, top:) visible_sprites([left, bottom, right - left, top - bottom]) end |
#reinitialize_sprites ⇒ Object
Overrides SimpleLayer#reinitialize_sprites or ActiveLayer#reinitialize_sprites Clears the @sprites array, based on the logical_height and logical_width of the LayerGroup
28 29 30 31 32 |
# File 'lib/zif/layers/tileable.rb', line 28 def reinitialize_sprites super # puts "#{@layer_name}: Tileable#reinitialize_sprites<EMAIL_ADDRESS><EMAIL_ADDRESS>@sprites =<EMAIL_ADDRESS>* @map.logical_width) end |
#remove_positioned_sprite(sprite) ⇒ Object
Overrides Layerable#remove_positioned_sprite Remove a sprite which has already been added. Finds the sprite by calculating its position in the @sprites array using #tile_pos_to_sprite_index and the sprite
‘s logical position.
54 55 56 |
# File 'lib/zif/layers/tileable.rb', line 54 def remove_positioned_sprite(sprite) @sprites[tile_pos_to_sprite_index(sprite.logical_x, sprite.logical_y)] = nil end |
#remove_tile(logical_x, logical_y) ⇒ Object
Clears the element in the @sprites array indicated by the logical position.
61 62 63 |
# File 'lib/zif/layers/tileable.rb', line 61 def remove_tile(logical_x, logical_y) @sprites[tile_pos_to_sprite_index(logical_x, logical_y)] = nil end |
#tile(logical_x, logical_y) ⇒ Zif::Sprite
Uses #tile_pos_to_sprite_index and returns the sprite at that position in @sprites
22 23 24 |
# File 'lib/zif/layers/tileable.rb', line 22 def tile(logical_x, logical_y) @sprites[tile_pos_to_sprite_index(logical_x, logical_y)] end |
#tile_pos_to_sprite_index(logical_x, logical_y) ⇒ Integer
Convert logical_x and logical_y to the index of the sprite in the @sprites array.
16 17 18 |
# File 'lib/zif/layers/tileable.rb', line 16 def tile_pos_to_sprite_index(logical_x, logical_y) (logical_y * @map.logical_width) + logical_x end |
#visible_sprites(given_rect = nil) ⇒ Enumerator
Overrides Layerable#visible_sprites This returns an enumerator which can be used to iterate over only the tiles which are visible. Only for layers which have allocated_tiles!
70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 |
# File 'lib/zif/layers/tileable.rb', line 70 def visible_sprites(given_rect=nil) # puts "Tileable#visible_sprites: #{@layer_name} '#{given_rect}'" if given_rect.nil? containing_sprite.view_actual_size! unless containing_sprite.source_is_set? left = containing_sprite.source_x bottom = containing_sprite.source_y w = containing_sprite.source_w h = containing_sprite.source_h else left = given_rect.x bottom = given_rect.y w = given_rect.w h = given_rect.h end logical_x =<EMAIL_ADDRESS>logical_y =<EMAIL_ADDRESS>x_range =<EMAIL_ADDRESS>y_range =<EMAIL_ADDRESS>max_y = [logical_y + y_range.ceil + 1, @map.logical_height].min max_x = [logical_x + x_range.ceil + 1, @map.logical_width].min # This enumerator is basically the equivalent of: # # @floor_tiles[logical_y..max_y].map do |x_tiles| # x_tiles[logical_x..max_x] # end.flatten.to_enum # # The benefit of doing this instead is that we avoid some extraneous iteration and allocation if we call # #visible_tiles more than once per tick. This definitely feels faster, but I haven't benchmarked. starting_a = [logical_x, 0].max starting_b = [logical_y, 0].max a = starting_a b = starting_b # puts " -> #{logical_x} #{logical_y} #{x_range} #{y_range} #{max_y} #{max_x} #{starting_a} #{starting_b} " Enumerator.new do |yielder| loop do next_tile = tile(a, b) yielder << next_tile if next_tile r, a = (a + 1).divmod(max_x) if r.positive? a = starting_a b += r end break if b > max_y end end end |


chatter|app
#Yummy
#SevenContinents
#KillerApp
#FirstPersonOnMars
#Octoberfest
#SevenContinents
by
cheeses.yard.applies
What's the place you folks call home?
BRISBANE! Hang loose!
thus.best.dishes
Wed, June 20th, 14:02
12 min. left
The big apple.
Eu sou um Carocas.
Greetings from the western cape!
北京


Human Practices
iGEM teams are unique and leading the field because they "go beyond the lab" to imagine their projects in a social/environmental context, to better understand issues that might influence the design and use of their technologies.
Teams work with students and advisors from the humanities and social sciences to explore topics concerning ethical, legal, social, economic, safety or security issues related to their work. Consideration of these Human Practices is crucial for building safe and sustainable projects that serve the public interest.
For more information, please see the Practices Hub.
Note
You must fill out this page in order to be considered for all awards for Human Practices:
- Human Practices silver medal criterion
- Human Practices gold medal criterion
- Best Integrated Human Practices award
- Best Education and Public Engagement award
Some Human Practices topic areas
- Philosophy
- Public Engagement / Dialogue
- Education
- Product Design
- Scale-Up and Deployment Issues
- Environmental Impact
- Ethics
- Safety
- Security
- Public Policy
- Law and Regulation
- Risk Assessment
What should we write about on this page?
On this page, you should write about the Human Practices topics you considered in your project, and document any special activities you did (such as visiting experts, talking to lawmakers, or doing public engagement).
Inspiration
Read what other teams have done:
Integrated Human Practices
Do you want to be considered for the Best Integrated Human Practices award? Make it easy for the judges to find any wiki content that is relevant to this prize. Highlight this content with a header or separate section.
Education and Public Engagement
Do you want to be considered for the Best Education and Public Outreach award? Make it easy for the judges to find any wiki content that is relevant to this prize. Highlight this content with a header or separate section.


Set up the socklog-notify service as described in Configuration to ensure that the named pipe /var/log/socklog/.notify exists. Do not delete this file after creation.
Read disable notifications before stopping the socklog-notify service once it is started.
socklog-notify is handled by the uncat program.
Make sure the account running this log service is member of the socklog group adm. If it isn't, change it now. Make sure that the socklog-notify service is running.
Redirect the standard error output of svlogd to the named pipe socklog-notify is reading from. To do so, insert exec 2> /var/log/socklog/.notify as second line into /var/service/socklog-unix/log/run:
#!/bin/sh exec 2> /var/log/socklog/.notify exec setuidgid log svlogd \ main/main main/auth main/cron main/daemon main/debug main/ftp \ main/kern main/local main/mail main/news main/syslog main/usersvlogd's error messages are always log events.
To configure additional log events in /var/log/socklog/main/, use the e instruction in the config file of this log, see the svlogd man page. For example, if you want to be notified about all log messages of the priority alert, add a corresponding e instruction to the config file /var/log/socklog/main/config like this:
s999999 n10 e*.alert: *Then tell the log service to re-read the config files:
# sv hup socklog-unix/log
To configure the kind of notification, edit /etc/sv/socklog-notify/run and change the prog argument of uncat to your needs. This example uses sms_client to notify:
#!/bin/sh -e PIPE=/var/log/socklog/.notify if [ ! -p "$PIPE" ]; then mkfifo -m0620 "$PIPE"; chown log:adm "$PIPE"; fi exec <> "$PIPE" exec setuidgid log uncat -s49999 -t90 \ sh -c 'head -c140 | sms_client pager'Then restart the service:
# sv restart socklog-notify
Another example using wall:
exec setuidgid log uncat -vs49999 -t180 sh -c 'head | wall'
# grep -F /var/log/socklog/.notify /var/service/*/log/runFor each of these services, edit the corresponding log/run script to remove the exec 2>/var/log/socklog/.notify line and the configured log event(s) and restart its log service:
# sv restart <service>/logNow it is safe to stop the socklog-notify service.


Decrease in the intensity of the M–OH 2 stretching band (550 to 590 cm −1) of the FeL14 complex by addition of the DPPH free radical. Shift of the aromatic C–H in-plane bending band of the DPPH radical in the presence of the FeL14 complex and signal enhancement proportional to the DPPH concentration.


Helwyr is a UNIX-like, (aiming to be) POSIX-compatible, from-scratch hobbyist operating system kernel.
The source code can be found on GitHub!
This is how it looks today:
This screenshot shows that Helwyr is able to run a
couple of interesting applications, including the default shell of
Ubuntu, dash, with working shebangs. It's also running GCC 6.2.0
and binutils 2.27 to compile a simple, Hello World program written in C.
|
A few gifs:
In this animation, we are testing out multiple important parts of
Helwyr. First, we see the use of the VGA-powered virtual terminals,
in Linux these are accessible usually via
|
|
|
|
Following on, we play the terminal version of the game 2048 to stress test the Virtual Terminal support along with its escape sequences. |
|
|
In this recording, we show that Helwyr supports multiple virtual terminals.
Switching between them is possible via
|
Here are a couple, collected screenshots:
This is the earliest screenshot I could find, showing basic paging,
a keyboard driver and a very basic
|
|
|
|
Woohoo, this is an Ethernet driver in Helwyr! It shows that Helwyr was able to determine that a PCI device is an E1000 compatible Ethernet card, the driver then proceeds to read the MAC address from the EEPROM. |
|
|
This screenshot shows that debugging Helwyr via GDB is possible, thanks to qemu. The stack trace is Helwyr constructing a UDP packet to test the driver. I used Wireshark to capture the packet on a bridge, this way I could confirm that the packet was indeed sent and the E1000 driver was performing well. |
|
|
This screenshot is from "the other side". It's on my laptop. Running a simple TCP server written in Python in about 23 seconds. We can see that Helwyr has successfully established a TCP connection to this server, and has sent it a simple text message. |
|
|
This is an early screenshot showing that the famous, system call
|
|
|
Struggling to get a C++ runtime working. For some reason, C++ decided
to allocate too much RAM, and a bug in the virtual memory subsystem
created an infinite loop that exhausted the kernel memory. This screenshot
is also a nice example of the advanced (Linux-like) stack traces the
kernel produces on a
|
|
|
The first, working run of a native assembler! This is from the GNU binutils package, version 2.27. |
|
|
Trying to assemble a simple test file that contained a hello world example. Many bugs in the VFS and the ext2 driver were found! |
|
|
Running the
|
|
|
A screenshot from the weeks of struggling in order to get GCC running. I was really determined to get GCC to work as that was my first real milestone. It was worth it. |
|
|
I broke qemu! |


Showoff uses many modern web technologies, such as CSS transforms and the Flexbox layout mode that's only been in use for about five years or so.
While we'd dearly love to support your browser of choice, it's genuinely infeasible to do so. Instead, we suggest that you update to a more recent browser. Any major browser released in the last few years will work. Even Internet Explorer 11 or above will work reasonably well.
If you are on a corporate Windows machine with locked down installation privileges, we also suggest trying out Portable Chrome, which will install into a self-contained bundle into your user profile only.


1000 ft.
Where is Chinatown?
The Boston Redevelopment Authority’s map of Chinatown is much smaller than that of the community, which says the neighborhood includes areas farther north and south. The BRA has approved major redevelopment projects outside its defined Chinatown borders.
SOURCES: BRA, Chinatown Master Plan 2010
Gabriel Florit, Bennie DiNardo, Maria Sacchetti / Globe Staff


JGL Prints Feedback
Made by JGL Form Solutions
Feedback
Rate us From 1 to 5
1
2
3
4
5
Visit our Website:
JGL 3D PRINTS