With this model I seek to illustrate the mechanisms at work in larger models featured later in this paper. The simple model features one sector, TFP only (or labor productivity) and log-utility both in consumption (unitary risk aversion) and labor.
\[ \label{eq:toy_preferences} E_0 \sum_{t=0}^{\infty} \beta^t [ \nu \ln \tilde{C}_t + (1-\nu) \ln (1- \tilde{L}_t)] \]
The following, transformed, variables are stationary:
\[ \label{eq:toy_stationary_variables} C_t := \frac{\tilde{C}_t}{A_{t-1} }, \quad K_t := \frac{\tilde{K}_t}{A_{t-1} }, \quad I_t := \frac{\tilde{I}_t}{A_{t-1} }, \quad L_t := \tilde{L}_t \]
In terms of stationary consumption and labor: \[ E_0 \sum_{t=0}^{\infty} \beta^t [ \nu \ln (A_{t-1} ) + \nu \ln C_t + (1-\nu) \ln (1- L_t)] \] \[ E_0 \sum_{t=0}^{\infty} \beta^t [ \nu \ln C_t + (1-\nu) \ln (1- L_t)] \, + \, \nu E_0 \sum_{t=0}^{\infty} \beta^t \ln (A_{t-1} ) \]
Assuming the last term is finite, and this puts a bound on the growth of TFP vis-a-vis the discount factor, then finding the optimal plans of consumption and labor (i.e. \( \tilde{C} \) and \( \tilde{L} \)) that maximize , itâs equivalent to finding optimal plans of TFP-scaled consumption and labor (\( C \) and \( L \)) that maximize
\[ \label{eq:toy_preferences_stationary} E_0 \sum_{t=0}^{\infty} \beta^t [ \nu \ln C_t + (1-\nu) \ln (1- L_t)] \]
\[ \label{eq:Fisher_prod_tilde} \tilde{Y}_{t} = A_t^{1-\alpha} \tilde{K}^{\alpha}_{t} L^{1-\alpha}_{t} \]
\[ \label{eq:toy_CIYtilde} \tilde{C}_t + \tilde{I}_t \leq \tilde{Y}_{t} \]
\[ \label{eq:toy_Kevol_tilde} \tilde{K}_{t+1} = I_t + (1-\delta) K_{t} \]
implying
\[ \label{eq:toy_CKYtilde} \tilde{C}_t + \tilde{K}_{t+1} - (1-\delta)\tilde{K}_{t} \leq A_t^{1-\alpha} \tilde{K}^{\alpha}_{t} L^{1-\alpha}_{t} \]
\[ \begin{aligned} A_{t+1} = & A_{t}~ e^{a_{t+1}}, \quad A_0 ~\text{given} \end{aligned} \]
\[ \label{eq:toy_a_contem_state} a_{t+1} = \mu_{a} + \zeta_{a,t+1} + \sigma_{a} w_{a,t+1} \]
\[ \begin{aligned} \label{eq:toy_z_s_contem_state} z_{t+1} & = A_z z_{t} + C_z w_{t+1} \\ s_{t+1} & = D_s z_{t+1} + G_s w_{t+1} \end{aligned} \]
\[ z_{t} := \begin{bmatrix} \mu_a \\ \zeta_{a,t} \end{bmatrix}, \quad w_{t} := \begin{bmatrix} w_{\zeta_a,t} \\ w_{a, t} \end{bmatrix}, \quad A_z := \begin{bmatrix} 1 & 0 \\ 0 & \rho_a \end{bmatrix} \]
\[ C_z := \begin{bmatrix} 0 & 0 \\ \sigma_{\zeta_a} & 0 \end{bmatrix} , \quad D_s := \begin{bmatrix} 1 & 1 \end{bmatrix},\quad G_s := \begin{bmatrix} \sigma_a & 0 \end{bmatrix} \]
This choice of matrices \( C_z, G_s \) implies that all shocks are orthogonal to each other.
\[ \begin{bmatrix} \mu_a & \zeta_{a,0}\end{bmatrix}' =: z_0 \sim N(\check{z}_0, \Sigma_0), \quad \text{ with sufficient statistics } \{\check{z}_0, \Sigma_0\} \]


---
layout: archive
title: "学习笔记"
date:
modified:
excerpt: ""
tags: []
image:
---
以下是我的学习笔记
[RWD学习笔记](https://161013029.github.io/posts/rwd)
{% for post in site.categories.rwd %}
{% include post-grid.html %}
{% endfor %}
[Infovis学习笔记](https://161013029.github.io/posts/infovis)
{% for post in site.categories.infovis %}
{% include post-grid.html %}
{% endfor %}


This extension automatically repeats requests, with replacement rules and response diffing. It provides a general-purpose solution for streamlining authorization testing within web applications.
AutoRepeater provides the following features:
- Automatically duplicate, modify, and resend any request
- Conditional replacements
- Quick header, cookie, and parameter value replacements
- Split request/response viewer
- Original vs. modified request/response diff viewer
- Highilight logs
- Filter logs
- Base replacements for values that break requests like CSRF tokens and session cookies
- Renamable tabs
- Logging
- Exporting
- Toggled activation
- "Send to AutoRepeater" from other Burp Suite tools


Anna and the King
Anna and the King is a movie starring Jodie Foster, Yun-Fat Chow, and Bai Ling. The story of the romance between the King of Siam and widowed British schoolteacher, Anna Leonowens, during the 1860s.


# concise, close to idiomatic Python
# (maybe add second method to deliver names for metrics (like Keras does with ``model.metrics_names``))
mean, std, min, max, _ = ppoAgent.score()
mean, std, min, max
# verbose, flexible, clearer for first time users
metrics = ppoAgent.evaluate()
metrics['mean'], metrics['std'], metrics['min'], metrics['max']


What do you have in mind today?
Forgotten your password?
Teamwork is an internal social network for organizations’ employees. The goal of this application is to facilitate more interaction between colleagues and facilitate team bonding.


Intended to assist in the choice of the sampling strategy to implement in a survey. It compares five strategies having into account the information available in an auxiliary variable and two superpopulation models, called working and true models.
| Version: | 1.1 |
| Depends: | shiny |
| Published: | 2018-09-10 |
| Author: | Edgar Bueno |
| Maintainer: | Edgar Bueno <edgar.bueno at stat.su.se> |
| License: | GPL-2 |
| NeedsCompilation: | no |
| CRAN checks: | optimStrat results |
| Reference manual: | optimStrat.pdf |
| Package source: | optimStrat_1.1.tar.gz |
| Windows binaries: | r-devel: optimStrat_1.1.zip, r-release: optimStrat_1.1.zip, r-oldrel: optimStrat_1.1.zip |
| OS X binaries: | r-release: optimStrat_1.1.tgz, r-oldrel: optimStrat_1.1.tgz |
| Old sources: | optimStrat archive |
Please use the canonical form https://CRAN.R-project.org/package=optimStrat to link to this page.


You can upload only one file. If you want to upload more,
do them in the Zip or Rar archive.
Supported formats: .doc, .docx, .pdf, .png, .jpg, .zip, .rar


{% extends "templates.jinja/base.page-with-navbar.html" %} {% block title %} Hesperian - Pregnancy & Birth{% endblock %} {% block id %}Seizures_during_pregnancy{% endblock %} {% block content %}
When a woman has a seizure, she may have some or all of these signs:
A seizure may last anywhere from a few seconds to many minutes.
Get medical help as soon as possible when the seizure is over.
{% endblock %} {% block footer %} {% endblock %}


---
layout: post
title: Joining the IJATS ERB
date: '2011-04-01T17:42:00.001+02:00'
author: Luca Ferrari
tags:
- research
modified_time: '2011-04-10T11:36:14.354+02:00'
blogger_id: tag:blogger.com,1999:blog-1836481905487384887.post-1143093259845279901
blogger_orig_url: http://fluca1978.blogspot.com/2011/04/joining-ijats-erb.html
permalink: /:year/:month/:day/:title.html
---
~
I'm proud to announce that the Editor in Chief has officially asked me to become a member of the Editorial Review Board of the
International Journal of Agent Technologies and Systems. And I'm happy to say I accepted this opportunity, so now I'm officially on the Editorial Review Board of IJAS.
This means that I will be selected to do paper reviews and to evaluated scientific works submitted to this journal. I see this as an opportunity to improve my scientific skills and I'll do my best to peer review every work I will be ask to review.


|
Neural Network (Deep Learning)
Mini-project 1
|
Encapsulates information and functions associated with layers. More...
#include "Layer.h"
Public Member Functions | |
| Layer (int numb, int activation) | |
| ~Layer () | |
| Destructor. More... | |
| void | setLayerUOutProp (int unitId, double value) |
| double | unitBackPropagate (int ii) |
| void | setUnitOutput (int ii, double value) |
| void | setUnitDelta (int ii, double value) |
| void | setActivation (int activation) |
| void | setNumbUnits (int numberOfUnits) |
| double | getUnitOutput (int ii) const |
| double | getUnitDelta (int ii) const |
| int | getNumbUnits () const |
| double | getActivation () const |
Private Attributes | |
| int | m_activation |
| Id of the activation function if the same for all units in the layer. More... | |
| int | m_numberOfUnits |
| Number of units. More... | |
| vector< Unit > | m_layer |
Encapsulates information and functions associated with layers.
Layer is composed of Units (Neurons) has associated activation funciton (if all the neurons within this layer share the same).
| Layer::Layer | ( | int | numb, |
| int | activation | ||
| ) |
| void Layer::setLayerUOutProp | ( | int | unitId, |
| double | value | ||
| ) |
| double Layer::unitBackPropagate | ( | int | ii | ) |
|
private |


Soma Halisi
About
Bookstore
Contact Us
Your Name:
This field cant be blank *
Publishers:
Please Select Publisher
Longhorn Kenya Ltd
East African Educational Publishers
WordAlive Publishers Limited
kenya literature bureau
This field cant be blank *
View Books
Books:
Please select Book
Literary Genres
journals
magazines
newspapers
This field cant be blank *
Location:
Please Choose Location
Nairobi
Mombasa
Nakuru
Kericho
Eldoret
Nyeri
This field cant be blank *
Check Verified vendors
Request Details Panel
Verified Vendors / Distributors


This is my favorite download-script, it works with files bigger than 10 MB on Apache 1.3 (or higher). I added the cache control to open also text files and others (without saving). Use this example code to download files from a protected directory for example.
<?php // place this code inside a php file and call it f.e. "download.php" $path = $_SERVER['DOCUMENT_ROOT']."/path2file/"; // change the path to fit your websites document structure $fullPath = $path.$_GET['download_file']; if ($fd = fopen ($fullPath, "r")) { $fsize = filesize($fullPath); $path_parts = pathinfo($fullPath); $ext = strtolower($path_parts["extension"]); switch ($ext) { case "pdf": header("Content-type: application/pdf"); // add here more headers for diff. extensions header("Content-Disposition: attachment; filename=\"".$path_parts["basename"]."\""); // use 'attachment' to force a download break; default; header("Content-type: application/octet-stream"); header("Content-Disposition: filename=\"".$path_parts["basename"]."\""); } header("Content-length: $fsize"); header("Cache-control: private"); //use this to open files directly while(!feof($fd)) { $buffer = fread($fd, 2048); echo $buffer; } } fclose ($fd); exit; // example: place this kind of link into the document where the file download is offered: // Download here ?>
Updates:
Added an example how to use this script with the filename from a query string
Mved the disposition header into the switch because the attachment attribute is sometimes needed
Using the function pathinfo() to get the file information (extension) now
Added the function stringconv() to handle also extensions with caps.
Demo:
The demo page demonstrate the functions file upload / download and handle directories


Celtic squad revealed as Mikey Johnston could return for Hibs showdown
Scott Brown is struggling for fitness ahead of the Betfred Cup semi-final at Hampden.
by Record Sport OnlineSkipper Scott Brown is struggling to be fit for Celtic's Betfred Cup semi-final against Hibernian at Hampden Park on Saturday.
The midfielder went off with a thigh injury in the 2-0 home win over St Mirren on Wednesday night and is a doubt.
He declared himself fit afterwards but Celtic boss Neil Lennon revealed earlier on Friday the veteran could now miss the showdown against his former club.
Striker Vakoun Bayo will see a specialist on Monday with regards a knee problem, Leigh Griffiths and Mikey Johnston are back in training while Jozo Simunovic (knee) remains out alongside Daniel Arzani (knee) and Greg Taylor is cup-tied.
Hibs, meanwhile, will assess winger Martin Boyle after he made his comeback off the bench from an ankle break in midweek.
Boss Paul Heckingbottom also reported multiple knocks on unnamed players.
Potential line-up
Provisional squad
Forster
Frimpong
Bauer
Elhamed
Ajer
Bolingoli
Jullien
Rogic
Bitton
Brown
McGregor
Ntcham
Forrest
Edouard
Christie
Hayes
Morgan
Johnston
Griffiths
Elyounoussi
Gordon


This article was posted to the TDN by Steven A. Hine.
First I'd like to acknowledge the person who wrote the aStar code. This is an awesome resource. Thanks Phil. After trying to implement this in a few games I finally figured it out. Here is the easiest way to use aStar.
First create a new project called aStarFollowing, add the puzzle template, and check the copy executable box.
Next we will need to add some behaviors to make the player and camera move. (You can get the behaviors from the Shooter game demo included with Torque 2D.) Simply copy the behaviors from the Shooter\game\behaviors folder into the \aStarFollowing\game\behaviors folder.
The next step to do is to reload T2D's editor. This can be done by going to the project menu and clicking 'reload project'. This will add the new behaviors to the editor.
Now the aStar files need to be added to the scripts folder. They should be in T2D's installed folder: \Program Files\Torque\TorqueGameBuilder-1.7.5\games\AStarDemo\game\gameScripts. Copy the files aStarActor.cs and aStarPath.cs into the \aStarFollowing\game\gameScripts folder.
All files are setup except the scripts we need to create. The next section will set up the scene for interaction with the player and AI.
aStar uses a tile map to process path calculations. Each tile in the map is a location in the game world that the AI can either be on or have to move around. This is set up is by using the tile editor to create values for each tile in the map. First drag a new newlayer object into the level area from the tile maps tab. Change the tile count x/y to 30 and tile size x/y to 5. Then press the size object to layer button to show all the tiles.
To add tiles to the map press the tile editing tab to reveal the edit controls:
First, under image find the puzzleBlock_1ImageMap. Then under custom data delete 'none' and type in 10. This is where aStar will find the value to rate each tile. Each tile in the map does not have to be done. Only the tiles that need to have a value higher than 0 will have to be done. Check the Collision box so that the player can't pass through our walls.
A value of 0 means that the AI can move on to the tile, higher values tell aStar to move around the tile. 10 is the highest value and impassable. The AI will not be able to use this tile. When a tile's custom data is set a circle with a 'C' in it will be put in the top left hand corner of the tile.
After setting up the tile, save the tile setup as a Brush. Here are the steps again:
Next, create a floor brush using frame 3, Custom Data set to 0 and Collision off.
Now, select your wall brush and paint walls, then select your floor brush and use the Flood Fill tool to paint the floor.
Build a map that resembles the following:
Lastly, scroll down to the 'scripting' tab and enter 'pathLayer' into the class field. This hooks the tile layer with the aStar $PathGrid global variable.
To see how well aStar works, a player will be added with keyboard controls of left, right, up, and down. Press the create button to show the 'Static Sprites' tab. Choose any image from the tab and drag it into the scene into the tile layer. With this image still selected select the Edit tab and open the 'Behaviors' rollout. Click the drop-down to open the list of available behaviors. This is what it should look like:
The behaviors we copied from the Shooter project should appear. If they are not there, check to see if they are in the correct folder (/'project name'/behaviors/) and reload the project. When asked to save the project, save it as start.t2d.
Select Shooter Controls and click the green 'plus' button ( ) to add the behavior to the object. Change the setting in the Shooter Controls to this:
If the scene was played now, the keyboard arrows would move the object around the screen. The controls are now set up.
Open the Scripting rollout and name your player object 'thePlayer', then set the Class attribute to 'playerClass'. This will let us mount the camera to the player as well as handle a few other things in script.
Now the player is set up. Next we'll add the AI and scripts to set up the aStar movement.
First choose a Static Sprite and drag it into the scene inside the tile map. It should be put between the blocks in the map. Open up the scripting tab and enter this information: Name: pAI Class: AIClass Super Class: aStarActor.
It is always good to give object a unique name. The class will be used to add some more functionality to the object through script. Finally the super class aStarActor will add all the functions need to give control to the aStar system.
While we're here, let's give the enemy a Face Object behavior and have it face the player object:
At this point the level can be saved as 'start.t2d' and T2D closed.
aStar works by making each tile in the tile map a node that the AI can move to. Of course, whether or not the tile is used depends on the custom data value that it has. All the blocks we added earlier have a value of 10, so they are not usable and aStar will move around them. It is assumed that any tile that does not have its custom data set has a value of zero.
In this picture the AI moves in the path shown by the arrows , because it is the shortest path of tiles that are open.
If you need a more in depth understanding of aStar, there are many resources on the internet as well as books on the subject. All of these calculations happen in engine code as they are set up and requested by the game scripts.
To get aStar to work, open up a new notepad file and type in this code:
function AIClass::onLevelLoaded(%this, %sceneGraph) { %this.moveSpeed = 10; %this.enableUpdateCallback(); } function AIClass::onUpdate(%this) { %this.startPath(%this.getPosition(), $thePlayer.getPosition()); }
First the onLevelLoaded function is used to set up the moveSpeed variable. This variable is used to tell aStar how fast the AI should move to the next tile or node in the tile map. Then the onUpdate callback is enabled, so that the player and AI position can be passed to aStar. aStar will use these to create the path. Next, type in this code below the onUpdate function.
function AIClass::startPath(%this, %start, %dest) { // find our path %this.pathGrid = $pathGrid; %newPath = %this.findDestinationPath(%dest); if (isObject(%newPath) ) { %this.currentPath = %newPath; %this.followAStarPath(%newPath); activeActorsSet.add(%this); } else { %this.isFrustrated("noPath"); } }
This code comes from the aStar demo in the sample games distributed with T2D. First a function called startPath is declared for the AIClass. In it we pass a start destination (%start) and a end destination (%dest). Next a pathGrid object is created that points to the aStarPath tileLayer from the level. A %newPath is created by calling aStarActor findDestinationPath. This function was added to the AI by the super class. It tries to find a path to the destination passed to the startPath function.
If a newPath is created, the code continues through the 'if' statement. The currentPath is updated with the newPath. Next the AI is told to follow the path by calling followAStarPath from the aStarActor supr class. Lastly, this object is added to the activeActorsSet, which will update the path if the game world has changed.
When a path is not found to the object, the else statement is executed. The isFrustrated function is called, which states there is no path. The isFrustrated function can be changed to create different behaviors. The most obvious is when a path was tried several times with no conclusion. By keeping count of how many tries were made, the AI's last try could tell it to do some other action. These actions could be to wait, random directions, or give up. Save the file as 'Actor.cs'.
Create another new file and enter the following code:
function playerClass::onLevelLoaded(%this, %scenegraph) { $thePlayer = %this; %this.class = playerClass; $thePlayer.setCollisionMaxIterations(2); %force = 20; sceneWindow2D.mount($thePlayer, "0 0", %force, true); // register with our possible destinations list if (!isObject(DestinationSet) ) { $targets = new SimSet(DestinationSet); } DestinationSet.add(%this); }
This sets up a global $thePlayer variable that we can use to access the player from anywhere in our scripts. It also keeps the collision detection system from bogging the system down by setting the maximum iterations to 2. This basically limits the processing done when your player object collides with one of your wall tiles. Then it mounts the camera to the player so that we can watch ourselves wander about our level. Finally, it puts our player on the destination list for the aStarActor objects in the game so that they will follow us. Save this file as 'player.cs'.
Before any of the above code will run, T2D needs to be told to compile the new file as well as aStarActor and aStarPath. Add this code to the main.cs file in the 'game' directory of the project. It goes below the 'Exec game scripts' line::
exec("./gameScripts/aStarActor.cs"); exec("./gameScripts/aStarPath.cs"); exec("./gameScripts/actor.cs"); exec("./gameScripts/player.cs");
These lines should be self explanatory. Save the file and close notepad. At this point the scene can be run. Open up T2D and run the scene. The AI should chase the player around the scene avoiding the blocks in the tile map.
After this basic coverage of the A-Star pathfinding system hopefully you are now ready to set up and use it in your games. Additionally, in this post Kevin Hawkins adds line-of-sight calculation to the existing A-Star pathfinding system.


# Time-interleaved SAR ADC generator
### (Notice: Sep. 4th 2018) #### The TISARADC generator has been completely refactored/fixed by Woorham Bae. Please carefully read this document.
This section describes how to generate a time-interleaved SAR ADC schematic and layout using BAG and laygo.
## Overview
Time Interleaved Successive Approximation ADC (TISARADC) is a popular way of implementing a moderate precision (4-10 bits) ADC that operates at higher sampling rates than single SAR ADCs can achieve. As an example
of demonstrating the automated analog and mixed signal circuits generation flow, the entire TISARADC generator is explained here.
## Installation
1. Set up a BAG/laygo working directory for the your technology. For example, cds_ff_mpt environment can be set up by running the following commands.
` $ git clone git@github.com:ucb-art/BAG2_cds_ff_mpt.git $ cd BAG2_cds_ff_mpt $ git submodule init $ git submodule update $ git submodule foreach git pull origin master `
> Note: for BWRC users, comprehensive working environments are provided under proper NDAs for certain technologies. Use the following repos and skip step 2, 3, 5, 6.
> 1. tsmc16FFC:
`git@bwrcrepo.eecs.berkeley.edu:jdhan/TISARADC_TSMC16FFC.git`
> 2. tsmc28hpm:
2. Copy configuration files and design libraries from laygo/generators/adc_sar/yaml by typing:
` cp laygo/generators/adc_sar/yaml/adc_sar_spec.yaml . cp laygo/generators/adc_sar/yaml/adc_sar_size.yaml . cp -r laygo/generators/adc_sar/BagModules/adc_sar_templates BagModules/ cp -r laygo/generators/adc_sar/adc_sar_templates . cp -r laygo/generators/adc_sar/adc_sar_testbenches . `
> Note: some repos may already have those files in their working directories.
Add library definitions to your cds.lib (some distributions use cds.lib.core instead of cds.lib)
In cds.lib
` DEFINE adc_sar_templates ./adc_sar_templates DEFINE adc_sar_testbenches ./adc_sar_testbenches `
3. Open bag_lib.defs and remove the definition of adc_sar_templates if exist
In bag_lib.defs` adc_sar_templates BagModules #remove this `
- Run virtuoso and type the following command in CIW.
` load "start_bag.il" `
- Open adc_sar_templates/capdac and update the library name of C0 and
CDAC0 to (technology_name)_micretemplates_dense, as shown below.
![ In the IPython interpreter, type the following command to construct the template and grid database. (Make sure proper techlib is attached to the microtemplate library)
` run laygo/labs/lab2_a_gridlayoutgenerator_constructtemplate.py `
6. Run the following command to generate the logic gate template library. The library name will be (technology_name)_logic_templates.
` run laygo/generators/logic/logic_templates_layout_generator.py `
## Setting up parameters
ADC schematic and layout are constructed based on spec/size parameters defined in 2 configuration files in YAML format (adc_sar_spec.yaml, adc_sar_size.yaml).
Following parameters are defined in the configuration files:
adc_sar_spec.yaml
- temp: nominal temperature
- temp_min: minimum temperature
- temp_max: maximum temperature
- v_in: nominal input swing (single ended)
- v_in_max: maximum input swing
- v_in_cm: nominal inpuut common mode
- n_bit: number of output bits
- n_bit_cal: number of output bits after digital calibration
- fsamp: effective sampling rate
- n_interleave: interleaving ratio
- c_unit: minimum unit capacitance of CDAC
- c_ground: grounded parasitic capacitance of c_unit
- c_delta: maximum capacitance mismatch of c_unit (normalized by
c_unit) * n_bit_samp_noise: standard deviation of sampling noise (in bits) * n_bit_samp_settle: maximum sampler settling error in bits * n_bit_comp_noise: standard deviation of comparator noise in bits * rdx_array: CDAC radix array * rdx_enob: Target ENOB after calibration * cycle_comp: Comparator timing budget in cycle * cycle_logic: Logic timing budget in cycle * cycle_dac: DAC timing budget in cycle * vdd: nominal supply voltage * vdd_min: minimum supply voltage * vdd_max: maximum supply voltage * trf_fo4: nominal logic transition timing * tfo4: nominal fo4 delay * samp_use_laygo: True if laygo is used for sampler generation. If false, AnalogBase is used * samp_with_tgate: True if T-gate sampler is used. IF false, NMOS-only sampler is used. Valid only if laygo is used for sampler generation. * ret_use_laygo: True if laygo is used for retimer generation. If false, AnalogBase is used * pmos_body: Default: VDD. Use VSS if flipped well is used. * use_offset: True if offset calibration is used for the comparator. * clk_pulse_overlap: Default: False. If true, sampling clock pulses for adjacent ADC slices will be overlapped.
- adc_sar_size.yaml
- device_intent: device intent (i.e. standard, lvt, hvt)
- lch: device channel length
- nw: width (number of fins) of unit NMOS
- pw: width (number of fins) of unit PMOS
- capdac
- c_m: multiplier of CDAC unit capacitor
- num_bits_horizontal: CDAC number of bits in horizontal direction
- num_bits_vertical: CDAC number of bits in vertical direction
- capdrv
- m_list: cap driver multiplier list
- space_offset: cap driver spacing parameter, for routing
- salatch
- doubleSA: True if double-tail sense amplifier is used
- m: strongArm latch input device sizing
- m_buf: strongArm latch output buffer sizing
- m_d: double-tail SA (second stage) input device sizing
- m_rgnn: strongArm latch regenerative latch sizing
- m_rgnp_d: double-tail SA (second stage) regenerative latch sizing
- m_rst: strongArm latch reset device sizing
- m_rst_d: double-tail SA (second stage) reset device sizing
- sarfsm
- m: SAR FSM sizing
- sarlogic
- m: SAR logic sizing
- num_inv_bb: Length of inverter chain for bottom-plate timing calibration
- sarclkgen
- fast: Fast mode - forced negative SARCLK (comparator clock) edge
- fo: SARCLK buffer fanout
- m: SARCLK generator sizing
- ndelay: For fast mode, # of delay units for negative edge
- sarret
- m: SAR logic output retimer sizing
- fo: SAR logic output retimer buffer fanout
- sarabe_m_space_left_4x: number of space cells
- sarabe_supply_rail_mode: Default:0. If VDD/VSS short is observed in “sar” hierarchy, use 1 and regenerate sarabe.
- sampler_nmos: for AnalogBase sampler
- fg_inbuf_list: input sampling clock buffer sizing
- fg_outbuf_list: output sampling clock buffer sizing
- fgn: sampler sizing
- nduml: # of dummy at the left side
- ndumr: # of dummy at the right side
- wn: NMOS width
- wp: PMOS width
- sarsamp: for Laygo sampler
- m_inbuf_list: input sampling clock buffer sizing
- m_outbuf_list: output sampling clock buffer sizing
- m_sw: unit sampler sizing
- m_sw_arr: # of unit sampler
- slice_order: Order of ADC slices, even number on the left side
- clk_dis_capsw
- m: clock generator capdac driving switch sizing
- clk_dis_cell
- m_dff: DFF sizing
- m_inv1: DFF Q buffer sizing (1st)
- m_inv2: DFF Q buffer sizing (2nd)
- m_tgate: Clock output tgate sizing
- clk_dis_cdac
- m: multiplier of CDAC unit capacitor
- num_bits: CDAC number of bits
- clk_dis_htree
- m_clko: number of tracks for clk_dis output clock
- m_track: number of tracks for input clock H-tree
- retimer
- ret_m_ibuf: input clock buffer sizing (last stage: ret_m_ibuf x 16)
- ret_m_latch: retimer latch sizing
- ret_m_obuf: output clock buffer sizing (ret_m_obuf x 4)
- ret_m_sr: duty-cycle correcting SR latch sizing
- ret_m_srbuf: SR latch output buffer sizing
For the starting point, following preset files are provided. They are not 100% finalized, but will serve well for initializations.
1. laygo/generators/adc_sar/yaml/adc_sar_spec(size).yaml : 8-way interleaved, 9bit ADC with digital calibration.
## TISARADC architecture
TISARADC is composed of 4 parts in the top level: ADC core, clock generator, output retimer and biasing.
- The ADC core performs the actual conversion operation. It is
composed of multi-phased sampling frontend and N subADC that converts the actual ADC operation at (sampling_rate/N), where N is the interleaving ratio. * The clock generator receives the high frequency clock at sampling rate, generates multi-phased clock for the interleaved ADC operation. * The output retimer receives the output from the ADC core, aligns multi-phased signals to a single clock to be received by the following digital backend.
![TISARADC](images/tisaradc_architecture.png)
## SubADC frontend layout generation
The frontend of subADCs is composed of three parts: capdac (CDAC), strongArm comparator (salatch), cap driver (capdrv). In the proposed flow, the ‘very’ frontend sampling switches are not the part of
subADC frontend because they are designed separately, but obviously this is not the only way of partition.
1. The first block to be generated is CDAC, since this generator assumes the horizontal dimension is limited by CDAC size in x-direction. In order to generate CDAC layout, type:
` run laygo/generators/adc_sar/adc_sar_capdac_layout_generator.py `
This command will create a CDAC layout in adc_sar_generated/capdac, as shown below.
![CDAC](images/tisaradc_capdac.png)
- The capdac generator reads n_bit and rdx_array parameters
from adc_sar_spec.yaml, and capdac_c_m, capdac_num_bits_vertical, capdac_num_bits_horizontal parameters from adc_sar_size.yaml (or use default settings in the python code if load_from_file is set to false), users can update those parameters and regenerate the capdac. It will create a new CDAC with different shapes, as shown below.
![CDAC](images/tisaradc_capdac_architecture.png)
![CDAC](images/tisaradc_capdac2.png)
If you want to generate the schematic as well, type:
` run laygo/generators/adc_sar/adc_sar_capdac_schematic_generator.py `
The figure shown below is one example of generated schematic. Note that CDAC capacitors (I0-I7) are arrayed, with radix parameters specified by rdx_array.
![CDAC](images/tisaradc_capdac_sch.png)
- The schematic generation is not required for full-ADC
generations, since you can generate the whole ADC schematic by running a top-cell generation script (unlike the layout counterpart, which requires running several scripts in series to generate the entire ADC). The CDAC schematic generation is used for cell level verifications though, such as LVS or transfer curve extraction. For LVS, type:
` run laygo/generators/adc_sar/adc_sar_capdac_lvs.py `
It will give a lvs passed message if the design is LVS clean.
>Note: BAG2_cds_ff_mpt / FreePDK45 does not support LVS & extraction at this moment. Skip these steps for those processes
For parasitic extraction, type the following command.
` run laygo/generators/adc_sar/adc_sar_capdac_extract.py `
> Note: this step could take a long time, depending on your extraction setup. Skip this if you just want to quickly go through steps.
You can run simulations on CDAC via BAG framework. The following
command will launch the transfer curve simulation with schematic netlists. For the post-extract simulation, set extracted = True in the script.
` run laygo/generators/adc_sar/adc_sar_capdac_verify.py `
![CDAC testbench options](images/tisaradc_capsim1.png)
![CDAC curve](images/tisaradc_capsim2.png)
![CDAC noise](images/tisaradc_capsim3.png)
2. After CDAC generation, PMOS-input sense amplifier layout can be generated by running:
` run laygo/generators/adc_sar/adc_sar_salatch_pmos_layout_generator.py `
![salatch](images/tisaradc_salatch_wDummy.png)
Note that the generator assumes the sense amplifier width is narrower than 2x of the CDAC width.
Two topologies available: StrongArm latch and double-tail sense amplifier
Here are additional scripts regarding the strongArm latch:
- adc_sar_salatch_pmos_size.py: transistor size calculator
![salatch](images/tisaradc_salatch_size.png)
2. adc_sar_salatch_pmos_schematic_generator.py: schematic generation 3. adc_sar_salatch_pmos_schematic_lvs.py: LVS 4. adc_sar_salatch_pmos_schematic_extract.py: RC extraction 5. adc_sar_salatch_pmos_verify.py: verifications (clk-q, noise)
![salatch](images/tisaradc_salatch_verify.png)
3. The next step is generating capacitor drivers that drive CDAC. Run the following scripts:
` run laygo/generators/adc_sar/adc_sar_capdrv_nsw_layout_generator.py run laygo/generators/adc_sar/adc_sar_capdrv_nsw_array_layout_generator.py `
This is a 2-step generation; in the first script, individual driver cells are generated. The second script places driver cells (with the sizing parameters defined by capdrv_m_list in adc_sar_size.yaml.
![capdrv](images/tisaradc_capdrv_structure.png)
![capdrv](images/tisaradc_capdrv_m_list.png)
Here’s one example layout of the capdrv.
![capdrv](images/tisaradc_capdrv.png)
Here’s the capdrv_array layout (primitive cells are hidden).
![capdrv](images/tisaradc_capdrv_array.png)
Now it’s time to generate the frontend top layout/schematic. Type:
` run laygo/generators/adc_sar/adc_sar_sarafe_nsw_layout_generator.py run laygo/generators/adc_sar/adc_sar_sarafe_nsw_schematic_generator.py run laygo/generators/adc_sar/adc_sar_sarafe_nsw_lvs.py `
The commands will create a layout (and schematic) of sarafe_nsw, which is the frontend top of subADC, and run LVS. Try different presets introduced before and see if designs are generated properly.
![sarafe](images/tisaradc_sarafe.png)
## SubADC backend layout generation
1. The backend of subADCs is composed of FSM(sarfsm), SAR logic(sarlogic), clock generator(sarclkgen), and retimer(sarret).
![sarabe](images/tisaradc_sarabe_architecture.png)
- SAR FSM: generates window signals that determines which SAR bit
corresponds to the current sense amplifier output.
- SAR logic: generates capdac control signal
![sarlogic](images/tisaradc_sarlogic_timingdiagram.png)
There are two path to the SAR logic, SA output and CLKgen/FSM, so timing between them should be checked. (t_ckgen + t_fsm + t_hold < T_SARCLK/2)
![sarlogic](images/tisaradc_sarlogic_timingcheck.png)
Timing check script: adc_sar_sarabe_dualdelay_verify.py
- SAR clock generator: generates the asynchronous clock for SAR search operation
- Fast mode on: clock pulsewidth is adjusted by a variable delay line.  Clock pulse will not disappear.
![sarclkgen](images/tisaradc_sarclkgen_fastoff.png)
SAR retimer: retimes the SAR logic output from the asynchronous clock domain with the synchoronous clock (sampling clock).
 For schematic generation, run scripts. Again, BAG is generating schematics in hierarachical order, so you don’t need to run these scripts if you want to generate in top level.
` #FSM layout run laygo/generators/adc_sar/adc_sar_sarfsm_schematic_generator.py #SAR logic run laygo/generators/adc_sar/adc_sar_sarlogic_wret_array_schematic_generator.py #SAR clock generator run laygo/generators/adc_sar/adc_sar_sarclkgen_static_schematic_generator.py #SAR retimer run laygo/generators/adc_sar/adc_sar_sarret_wckbuf_schematic_generator.py #spacing elements for routing/filling run laygo/generators/adc_sar/adc_sar_space_schematic_generator.py #SAR backend generation run laygo/generators/adc_sar/adc_sar_sarabe_dualdelay_schematic_generator.py `
3. The frontend and backend can be integrated by running following scripts.
` # layout run laygo/generators/adc_sar/adc_sar_sar_layout_generator.py # schematic run laygo/generators/adc_sar/adc_sar_sar_schematic_generator.py `
![sar](images/tisaradc_sar.png)
- Use “sarabe_supply_rail_mode” in adc_sar_size.yaml to avoid VDD/VSS short.
## SubADC switch generation
The sampling frontend can be generated either from laygo or AnalogBase. While the sampler generated from AnalogBase (written by Eric Chang) is more flexible, associated APIs need to be set up (which is not for the cds_ff_mpt technology), so laygo based sampler is used for this example.
Sizing script gives a simple calculation using the extracted MOS data.
![sarsamp](images/tisaradc_sarsamp_size.png)
Run the following script to generate the sampling switches.
`
# size
run laygo/generators/adc_sar/adc_sar_sarsamp_size.py
# layout
run laygo/generators/adc_sar/adc_sar_sarsamp_layout_generator.py
# schematic
run laygo/generators/adc_sar/adc_sar_sarsamp_schematic_generator.py
# testbench
run laygo/generators/adc_sar/adc_sar_sarsamp_verify.py
`
![sarsamp](images/tisaradc_sarsamp.png)
If the AnalogBase is set up for your technology, these scripts will generate the sampling switches.
`
# layout
run laygo/generators/adc_sar/sampler_nmos_layout_generator.py
# schematic
run laygo/generators/adc_sar/sampler_nmos_schematic_generator.py
`
Note that the Laygo provides a transmission gate switch option, but the AnalogBase provides guardring option.
## SubADC top generation
If all subblocks are generated sucessfully, the SubADC top (sar_wsamp) can be easily generated by placing and routing subcells. Run the following scripts to generate the SubADC top.
`
# layout
run laygo/generators/adc_sar/adc_sar_sar_wsamp_layout_generator.py
# schematic
run laygo/generators/adc_sar/adc_sar_sar_wsamp_schematic_generator.py
`
The generated layouts shown below are from the full-stack subADC generation with different settings (9b, 6b, 10bits and different sizing parameters).
![sar](images/tisaradc_sar_wsamp.png)
## SubADC testbench
Timing check: adc_sar_testbenches/sar_wsamp_9b_tb_tran_timing
Static testbench: adc_sar_testbenches/sar_wsamp_9b_tb_tran_static (ADC curve, calibration map, SNDR)
![ADC curve](images/tisaradc_sarwsamp_testbench1.png)
![SNDR](images/tisaradc_sarwsamp_testbench2.png)
## Array generation
The SAR array can be easily made from running the following scripts.
`
# layout
run laygo/generators/adc_sar/adc_sar_sar_wsamp_array_layout_generator.py
# schematic
run laygo/generators/adc_sar/adc_sar_sar_wsamp_array_schematic_generator.py
`
![sar](images/tisaradc_sar_wsamp_array.png)
## Clocking path generation
Zhongkai Wang and Woorham Bae made schematic and layout generators for the clock generation. The clock generator is basically a shift-register based divider, and each of the divided phaes is assinged to an ADC slice. The order of ADC slices is free to change, as long as we do not mess up the even and odd order.
![clkdis](images/tisaradc_clkdis_diagram.png)
![clkdis](images/tisaradc_clkdis_order.png)
The clock generator provides two modes: short pulse mode (default) and 2x pulse mode.
![clkdis](images/tisaradc_clkdis_mode.png)
Running following scripts will generate the clocking frontend. (You don’t need this for non-interleaving ADCs)
`
run laygo/generators/adc_sar/clk_dis_capsw_array_layout_generator.py
run laygo/generators/adc_sar/clk_dis_clk_dis_cell_layout_generator.py
run laygo/generators/adc_sar/clk_dis_capdac_layout_generator.py
run laygo/generators/adc_sar/clk_dis_viadel_cell_layout_generator.py
run laygo/generators/adc_sar/clk_dis_viadel_layout_generator.py
run laygo/generators/adc_sar/clk_dis_htree_layout_generator.py
run laygo/generators/adc_sar/clk_dis_viadel_htree_layout_generator.py
run laygo/generators/adc_sar/clk_dis_viadel_htree_schematic_generator.py
`
The following picture shows generated clocking paths for different interleaving ratio settings
![clkdis](images/tisaradc_clking.png)
## Retimer
The retimer is generated either of Laygo and AnalogBase.
![retimer](images/tisaradc_retimer.png)
![retimer](images/tisaradc_retimer_diagram.png)
Laygo generator codes for the final retimer is written by Woorham Bae. Run these scripts to generate the retimer schematic and layout.
`
run laygo/generators/adc_sar/tisaradc_retimer_layout_generator.py
run laygo/generators/adc_sar/tisaradc_retimer_schematic_generator.py
`
AnalogBase generator codes for the final retimer is written by Eric Chang. Run these scripts to generate the retimer schematic and layout.
`
run laygo/generators/adc_sar/adc_retimer_layout_generator.py
run laygo/generators/adc_sar/adc_retimer_schematic_generator.py
`
## TISARADC body (clock+sar+retimer)
Following scripts are for generating layout and schematic of TISARADC body.
`
run laygo/generators/adc_sar/tisaradc_body_core_layout_generator.py
run laygo/generators/adc_sar/tisaradc_body_core_schematic_generator.py
`
![clkdis](images/tisaradc_body_core.png)
## Bias
## Top
## Full stack generation
in laygo/generators/adc_sar, there are various levels of full-stack generators (generating all up to the specified hierarchy). Their filenames end with fullstack_generator.py
## Contributors
The generator codes are written by Jaeduk Han, Woorham Bae, Eric Chang, Zhongkai Wang, and Pengpeng Lu. This document is written by Jaeduk Han and Woorham Bae.


Java CLI Fractal Generator
For proper project documentation, refer here.
A Java fractal generator (currently UI-silent, with configuration through a file),
that implements display of custom functions,
with constant declaration processing, in Mandelbrot, Newton,Secant,Nova (both Mandelbrot and Julia types) and Julia
modes, and an experimental IFS/LS render system.
There are also Buddhabrot techniques ( naive algorithm ) for each of the above.
There are 36 different colouring schemes, 15 have linear interpolation, 17 have Catmull-Rom Spline interpolation and
2 which directly render in grayscale for emphasis on inner regions. The final is distance estimation based grayscale
or palette coloring, which is slow and has the same limitations as Newton/Nova mode as it uses the same mathematics
(symbolic differentiation) backend.
There's also an ASCII art output type, for, you know,
ComplexFractalGenerator
objects.
Degrees of functions are auto-calculated for use in calculating the renormalized iteration count.
The automatic degree calculation system might have a few issues with grouped operations, especially if considering
division or multiplication in the equation.
This calculation can be manually overriden after initializing the fractal generator with
setDegree(double)
of the ComplexFractalGenerator
object in theTest
class. This could be made more
accessible once a GUI is made.
Specifying a degree value in the configuration file will also override the calculation of the degree, which can
be a complex value.
Indexing of colours can be linear or logarithmic (which provides better results than sqrt scaling).
Colors can be interpolated directly or via their R, G and B components, or via their palette indices (in spline
interpolation only).
The spline-interpolant methods are the standard ones of Triangle Area Inequality, Curvature Average and Stripe
Average, as well as Histogram coloring (by extension Rank-Order mapping) and Color Distance Estimation,Orbit and
Line Traps and Gaussian Distance and Epsilon Cross, by default.
The linear interpolant methods have the 3 Newton fractal coloring modes, and the division and multiplication direct
and normalized coloring modes, and linear versions of the spline-interpolant methods,excepting distance estimation
and traps.
(Actually, they have it too, but it isn't a separate coloring mode,
toggle it with the modifier flag in the color configuration.
Spline interpolation is the default (flag is false).)
Resolution of the fractal is preferred to be in 2m+1x2n+1 format for proper symmetry.
Any resolution will work as long as it doesn't cause OOM (On my PC, it gives OOM errors at about 8K)
Supported modes: Julia, Mandelbrot, Newton, Nova (both mandelbrot and Julia variants) and Secant, with Buddhabrot
technique variations available for each.
The Newton/Nova fractal generator can handle simple polynomials with coefficients and exponents which are
expressions in themselves, but it uses a different input format:
coefficient: (optional)variable (optional): (optional)exponent (optional),+
or - or * or /,coefficient:variable:exponent...
Example: 1:z:3,-,c:z:2,+,1 (equivalent to (z3)-(c*z2)+1)
It can also handle simple transcendental functions like log,exp,sin,sinh,cos,cosh.
This is the input format:
polynomial; (optional)function (optional);polynomial (optional);exponent;constant (optional)|+
or - or * or /|polynomial;function;polynomial;exponent;constant...
The 1st polynomial is the coefficient,the 2nd is the function argument.
Only the coefficient is required, but if the function is supplied then everything except the constant is required.
Example: 1;sin;1:z:2;f (equivalent to sin(z2)+f)
Standard expressions can have embedded conditionals of the form:
[ conditional ? result if conditional is true : result if conditional is false ]
This is similar to the Java ternary operator syntax, and all Java primitive comparisons are supported, except:
Multithreading -- Available for complex number fractals and IFS fractals (not including L-System ones and animations)! Use is encouraged, but memory requirements are a bit high.
More standard coloring methods are there, such as:NOTES: The fractal generator is extensible and multithreaded, and multithreading works well, albeit being quite resource intensive, requiring about a 20x increase in memory requirements for about a 10x speedup during generation (12 threads). Also, there might be OOM errors in very intensive cases (20+ threads at 640x480).
Also, there is full support for zoom, but renders after zoom are slow for higher base precision values. There is also support for panning, but pure complex function fractals are the only ones which support on-demand panning, others require regenerating the fractal. As a thumb rule, for quadrupling total resolution, double base precision for best results.
OUTPUT:
Default debug and progress is output to console, and the final image(s) are saved serially as
Fractal_no..png
(except for animated IFS and/or L-System fractals, which are output frame-by-frame into a folder) in the output
directory specified in the CMD arguments to the program.
For test launches, the result is saved as Fractal.png
in the current working directory.
There is also an included image viewer, which can also generate and display standard complex number fractals.
Enable it with the -v
command-line switch.
There is support for elementary image transitions from top, bottom, left and right in the viewer, again
configurable.
However, saving of the fractal image and zooming in the viewer are both supported but untested.
All input to the application is currently handled by:
"#"
,
as in .ini
files.
I do not have much time for putting in documenting comments. I'll put them in and update files as and when possible.


We're sorry but test doesn't work properly without JavaScript enabled. Please enable it to continue.


Reservation Info
You can reserve tickets for any event you like from event detail page, just press the "reserve tickets" button. In case you need to update your reservation, repeat the process, selecting a different amount of tickets. For deleting any reservation, access your reservations page by clicking your name on the navbar and press the cancel button on the one you want to delete.
NOTE: you need to be logged in to reserve tickets or check reservations.
Where are we
- Piazza Leonardo Da Vinci, 32
- Milano
How to get the tickets
You can find our ticket office at Deib (Building 20). Remember to reserve the tickets on our site!
Ticket cost
With only 5€ you have access to one of our events. What are you waiting for?


Provides several metrics for assessing relative importance in linear models. These can be printed, plotted and bootstrapped. The recommended metric is lmg, which provides a decomposition of the model explained variance into non-negative contributions. There is a version of this package available that additionally provides a new and also recommended metric called pmvd. If you are a non-US user, you can download this extended version from Ulrike Groempings web site.
| Version: | 2.2-3 |
| Depends: | R (≥ 2.2.1), MASS, boot, survey, mitools, graphics |
| Imports: | methods, corpcor |
| Published: | 2018-03-10 |
| Author: | Ulrike Groemping [aut, cre], Lehrkamp Matthias [ctb] |
| Maintainer: | Ulrike Groemping <groemping at beuth-hochschule.de> |
| License: | GPL-2 |
| URL: | http://prof.beuth-hochschule.de/groemping/relaimpo/, http://prof.beuth-hochschule.de/groemping/ |
| NeedsCompilation: | no |
| Citation: | relaimpo citation info |
| Materials: | NEWS |
| In views: | Multivariate |
| CRAN checks: | relaimpo results |
| Reference manual: | relaimpo.pdf |
| Package source: | relaimpo_2.2-3.tar.gz |
| Windows binaries: | r-devel: relaimpo_2.2-3.zip, r-release: relaimpo_2.2-3.zip, r-oldrel: relaimpo_2.2-3.zip |
| OS X binaries: | r-release: relaimpo_2.2-3.tgz, r-oldrel: relaimpo_2.2-3.tgz |
| Old sources: | relaimpo archive |
| Reverse imports: | bootnet, RelimpPCR |
| Reverse suggests: | FactorsR, ic.infer |
Please use the canonical form https://CRAN.R-project.org/package=relaimpo to link to this page.


--- title: (BFTimeseriesAnnotationLayer) listAnnotations keywords: documentation theme, jekyll, technical writers, help authoring tools, hat replacements last_updated: July 3, 2016 tags: [getting_started] sidebar: matlab_docs_sidebar permalink: bftimeseriesannotationlayer_listannotations.html folder: mydoc ---
ANNOTATIONS2TABLE stores all of the annotations associated with a layer object in a MATLAB table. The output is a table that looks as follows: +---------------+-----------------+------------------------+------------+----------+ | ID | Name | Description | Start_Time | End_Time | +---------------+-----------------+------------------------+------------+----------+ | annotation_id | annotation_name | annotation_description | start_time | end_time | +---------------+-----------------+------------------------+------------+----------+ Args: end (int): end time for which to include annotations Examples: Store all the annotations in the "Seizures" layer (``sz`` object) for ``ts``, a timeseries object:: >> sz.annotations2table(ts.endTime) ans = 2×5 table ID Name Description Start_Time End_Time ______ _____________________ __________________________ __________________ __________________ '4853' 'Generalized Seizure' 'secondary generalization' '1301921827000000' '1301921832000000' '4850' 'Focal Seizure' '' '1301921822000000' '1301921822500000'
| Access | public |
| Sealed | false |
| Static | false |


Dr.Lehner
& Dr.Cadamuro
HOME
ORDINATIONSZEITEN
KONTAKT
LEISTUNGEN
PATIENTENINFORMATION
TEAM
DIE ORDINATION
404
Page not found
Sorry, but the page you were looking for could not be found.
Back to homepage


SpaceX Booster List
RTLS
Return To Launch Site
ASDS
Landed on Autonomous Spaceport Drone Ship
Expended
Landing failure
Failure
Planned
Hover for more info
Timeline view
Loading Data...
* Some core numbers are not known for early flights. The numbers shown are estimates based on flight order.
Made by niwax ( Twitter, Reddit, NSF) using the r/spacex API


| agg_ppm {ragg} | R Documentation |
The PPM (Portable Pixel Map) format defines one of the simplest storage formats available for image data. It is basically a raw 8bit RGB stream with a few bytes of information in the start. It goes without saying, that this file format is horribly inefficient and should only be used if you want to play around with a simple file format, or need a file-based image stream.
agg_ppm( filename = "Rplot%03d.ppm", width = 480, height = 480, units = "px", pointsize = 12, background = "white", res = 72, scaling = 1, bg )
filename |
The name of the file. Follows the same semantics as the file naming in [grDevices::png()], meaning that you can provide a [sprintf()] compliant string format to name multiple plots (such as the default value) |
width, height |
The dimensions of the device |
units |
The unit 'width' and 'height' is measured in, in either pixels (''px'‘), inches ('’in'‘), millimeters ('’mm'‘), or centimeter ('’cm''). |
pointsize |
The default pointsize of the device in pt. This will in general not have any effect on grid graphics (including ggplot2) as text size is always set explicitly there. |
background |
The background colour of the device |
res |
The resolution of the device. This setting will govern how device dimensions given in inches, centimeters, or millimeters will be converted to pixels. Further, it will be used to scale text sizes and linewidths |
scaling |
A scaling factor to apply to the rendered line width and text size. Useful for getting the right dimensions at the resolution that you need. If e.g. you need to render a plot at 4000x3000 pixels for it to fit into a layout, but you find that the result appears to small, you can increase the 'scaling' argument to make everything appear bigger at the same resolution. |
bg |
Same as 'background' for compatibility with old graphic device APIs |
file <- tempfile(fileext = '.ppm') agg_ppm(file) plot(sin, -pi, 2*pi) dev.off()


About Me
I have over three years of experience in customer and product support I became fascinated with troubleshooting and code when I was hired for my first technical role at a startup. I love putting on the Sherlock hat and believe my passion for troubleshooting customer issues across various platforms and in drastically different industries is a valuable strength. I would like to use my experience to produce code that always maintains focus on helping the user, allowing them to walk away happy with a good understanding of how to use a product I helped build. My goal is to use my skills as a developer to build sites for companies in 3D printing, media, consumer products, photography, or cybersecurity.
 Libero rutrum ut lacinia donec curae mus. Eleifend id porttitor ac ultricies lobortis sem nunc orci ridiculus faucibus a consectetur. Porttitor curae mauris urna mi dolor.


Would you like to save these colors for later?
What would you like to name this set of colors?
Are you sure you want to delete all of your saved palettes?
This action can't be undone.


Home¶
OFDFT-ML: Orbital free density functional theory run on machine learning¶
This project is aimed to implement the orbital free density functional theory in a machine learning way, our method will learn a effective energy functional from DFT calculated dataset, and find the ground state electron density of a given potential by solving Euler-Lagrange equation.
The project is organized as follows: * quantum subpackage: solve Schrodinger equation with a periodic potential in momentum space, solve Schrodinger equation with a finite range potential in real space * statslib subpackage: machine learning program library * tools: scripts used to generate dataset, analyze data and learning
Installation¶
Install OFDFT-ML from GitHub source:
First, clone OFDFT-ML using git:
git clone https://github.com/HamletWantToCode/ofdft-ml.git
Then, cd to the ofdft-ml folder and run the install command (install in develop mode):
cd ofdft-ml
pip install -e .
Requirement¶
Required packages: * numpy * scipy * matplotlib * mpi4py * scikit-learn==0.19.1
Python version 3.6
Getting started¶
Generate DFT data¶
To generate density and kinetic energy of electron in a periodic potential:
database.py -n 100 --params quantum_params k
will generate a dataset contains 100 data samples (each is a density-kinetic energy pair), the parameters used to generate the dataset are specified in “quantum_params” file, extra label k here is used to indicate that we are solving Schrodinger’s equation in momentum space.
the “quantum_params” file is a plain text file with lines:
n_basis=10 # indicate the number of plane wave basis being used to expand the wavefunction
n_kpoints=100 # indicate the number of k points sampled in the 1st BZ
n_cosin=3 # indicate the number of cosin functions used to construct the periodic potential
V0=1:10 # indicate the range of the amplitudes of the cosin functions (positive)
Phi0=-0.2:0.2 # indicate the range of phase of the cosin functions
occ=1 # indicate the electron occupation in a unit cell
To generate density and kinetic energy of electron in a finite range potential (Burke’s case):
database.py -n 100 --params quantum_params x
the “quantum_params” file is only different in specifying potential energy parameters, and the label x is used to indicate that we are solving Schrodinger equation in real space.
You can also use MPI to speedup the generating process:
mpirun -n 4 database.py -n 100 --params quantum_params k
Data preprocessing¶
You can visulize the electron density and potential distribution in real space using:
plot_rawdata.py --f_dens density_in_x --f_Vx potential_in_x
this will gives you “density_distribution.png” and “Vx_distribution.png”.
you can also run PCA to view electron density data, which is 500 dimension in a 2 dimensional space:
data_process.py -f density_in_x proc
the label proc represents for preprocessing.
NOTE: if you use k label in the data generating process, the Fourier components of electron density in momentum space is stored in dataset. In this case, you should first transfer the electron density to real space by:
k2x.py -n 500 -f density_in_k:potential_in_k
Model selection¶
Machine learning models contains hyperparameters that need to be specified before learning, to choose these hyperparameters properly, we use cross validation method, and do grid search inside a range of parameters.
To do grid search, you need first specify the parameter region in the “model_params” file:
n_components=1 # number of PCA components
C=-15:-8 # the range of penalty factor for kernel ridge regression (log based)
gamma=-8:-1 # the range gamma parameter for RBF kernel (log based)
ngrid=50 # number of grid in each dimension
and then run:
model_selection.py --f_dens density_in_x --f_grad potential_in_x -r 0.4 -n 5 --params model_params
here the –f_dens and –f_grad indicate the electron density data file and the corresponding potential, -r indicate the ratio between training and testing dataset, -n indicate the number of folds used in cross validation.
NOTE: The grid search program is implemented by Python’s multiprocessing module, and will use all the available CPU resources by default.
Machine learning & prediction¶
After grid search, you will have three new files: “demo_train_data”, “demo_test_data” and “demo_best_estimator”, these files are used to predict kinetic energy for the new sample and find ground state electron density for new potential.
NOTE: the prediction is done on the testing dataset in “demo_test_data” file.
to see the prediction, run:
data_process.py -f demo_train_data:demo_test_data:demo_best_estimator --params optim_params pred
pred label means we are predicting, and to do prediction, we need to specify parameters for a optimization algorithm (used to find ground state electron density), the “optim_params” files looks like this:
mu=10 # indicate the chemical potential
n=1 # indicate the electron number
step=0.01 # indicate the optimization step length
tol=1e-5 # indicate the tolerance for optimization


Your Diggernaut
API key
Error:
API key you entered is invalid.
Load Diggers
Select a digger
Error:
API key you entered is invalid.
Connect


You may fine-tune the selector to match only the elements you actually need. In this example only orange is draggable.


Enchantress
Tips
- Untouchable makes you a great hero to tank Rosh since he attacks in bullet time.
- You can Enchant nearly every enemy/neutral unit. Necronomicon creeps and enemy illusions are both A+++
steals.
- You can re-cast Enchant on a controlled unit to refresh the duration.
- Impetus calculates the damage by the distance between you and the target once the projectile hits the
target. There's a cap at 1750 distance.
- Impetus goes through spell immunity.
Counters
- If you're a right clicker, try to let your supports take care of Bambi. You'll be wasting your time
trying to kill her mid game when nukes will touch her Untouchable fluffy tail quicker than you can.


If you have any questions or comments, please post them below. If you liked this post, you can share it or follow me on Twitter !


Multiplatform Toolchain and IDE
Armstrap development relies on the open source “Eclipse” IDE, specifically configured for ARM development. Eclipse has some of the best advanced features that real-world developers know and depend on to make development productive. Developers can easily write code, flash their chip, debug and inspect variables at runtime, without any compromises or headaches. Armstrap Eclipse comes pre-configured with the GNU Tools for ARM Embedded Processors that works with Mac, Linux and Windows.. There are no licenses to worry about, and there are no serial USB keys to share.


Selling your MacBook? Here’s how to repair the butterfly keyboard for free and get more money
by Michael PotuckReady to pick up the 16-inch MacBook Pro with the scissor switch Magic Keyboard? If you’re thinking of selling your current MacBook to upgrade to Apple’s latest, follow along for how to repair or replace your current butterfly keyboard for free to get more money when you sell your notebook.
Apple’s butterfly keyboards in MacBooks that date back to 2015 have seen serious problems with debris being caught under keys. This causes keys to not work, or in some cases the computer registering a double press when keys are just pressed once.
All of Apple’s MacBooks with butterfly keyboards are eligible for the free service program. The 2018 MacBook Pro and MacBook Air featured the third-generation butterfly keyboard that includes a new gasket, but that didn’t fully solve the issue for many users.
Finally, even after 2019 MacBook Pro models included a new material in the keyboards (a fourth iteration), they became eligible for the keyboard service program as soon as they debuted.
So if you’re looking to sell your current MacBook, particularly on eBay, Swappa, Craigslist, or to a friend or family member, you’ll likely be able to sell it for more with a fully functioning, and maybe brand-new keyboard (and you’ll probably feel better handing it off knowing the keyboard isn’t glitching too 😄).
Per Apple’s keyboard service program, in some cases, they will replace the entire keyboard, and others may repair certain keys.
How to replace your MacBook butterfly keyboard for free and get more money when selling
- If you’re not sure, check your MacBook or MacBook Pro model ( → About this Mac)
- Check if your MacBook is part of the keyboard service program here or below
- If it is, get in touch and Apple will begin the repair or replacement process
- MacBook (Retina, 12-inch, Early 2015)
- MacBook (Retina, 12-inch, Early 2016)
- MacBook (Retina, 12-inch, 2017)
- MacBook Air (Retina, 13-inch, 2018)
- MacBook Pro (13-inch, 2016, Two Thunderbolt 3 Ports)
- MacBook Pro (13-inch, 2017, Two Thunderbolt 3 Ports)
- MacBook Pro (13-inch, 2016, Four Thunderbolt 3 Ports)
- MacBook Pro (13-inch, 2017, Four Thunderbolt 3 Ports)
- MacBook Pro (15-inch, 2016)
- MacBook Pro (15-inch, 2017)
- MacBook Pro (13-inch, 2018, Four Thunderbolt 3 Ports)
- MacBook Pro (15-inch, 2018)
- MacBook Pro (13-inch, 2019, Four Thunderbolt 3 Ports)
- MacBook Pro (15-inch, 2019)
Note: No other Mac notebook models are part of this program.
Earlier on in the keyboard repair program, Apple was sending out MacBooks with keyboard issues with a typical three- to five-day turnaround. Back in April, Apple started offering in-store keyboard repair and replacement with next-day turnaround for many customers.
Read more on the 16-inch MacBook Pro:
- 15-inch vs 16-inch MacBook Pro comparison: Should you upgrade?
- Poll: Are you buying Apple’s new 16-inch MacBook Pro?
- Phil Schiller says SD card slot and other ports ‘probably not’ ever returning to MacBook Pro
- The latest MacBook Pro has a different keyboard, so is it safe to buy an Apple laptop now?
- 16-inch MacBook Pro: Early hands-on demos compare size, keyboard, speakers, more
- Apple’s new 16-inch MacBook Pro still uses a 720p webcam and lacks Wi-Fi 6 — unlike iPhone 11
- Phil Schiller talks 16-inch MacBook Pro Magic Keyboard, Touch Bar, and more in new interview
- Apple announces new 16-inch MacBook Pro: scissor switch ‘Magic Keyboard’, louder speakers, $2399
FTC: We use income earning auto affiliate links. More.


In this tutorial, you will learn how to manipulate the position of the fire, and observe how that affects the evacuation time! Let's begin!
Since you are familiar with all the basic settings, let us introduce you to two new settings you can play with in order to vary the properties of fire. The two settings are "fire-location-chooser" and "incremental-fire-spread-chance"!
The "fire-location-chooser" setting can be found on the model interface below. The setting is in the form of a chooser interface where you can choose the location of the fire! After choosing the location, press setup and volia, the fire will be in one of the locations you specified! Just to refresh your memory, we have matched the colour of the map with the chooser settings under the "fire-location-chooser".
There you have it! Just choose which setting you want the fire to appear on and it will! Play around with the different positions to see the effect of the fire on the evacuation process. You might want to increase the number of minions to see any significant effect of the change in location of the fire. Another setting that you can vary is the "incremental-fire-spread-chance", which we will explain more in the next paragraph!
The "incremental-fire-spread-chance" setting is in the form a slider in the model interface below. The lowest value is 0, which indicates that the fire will not spread in each tick, while the value of 1 means that the fire will spread at every tick. Adjusting the value between 0 and 1 thus adjust the speed in which the fire spreads. Adjust this slider alongside the adjustments in the location of the fire to see how the fire agent affects the evacuation process overall.


Github.io With Bootstrap
Setting up Github.io page is super easy.
You just need create a public project with name:
[YOUR_GITHUB_USERNAME_HERE_WITHOUT_PARANTHESIS].github.io
Then just write a index.html file for this project to set up your static personal GitHub.io page.
It does not look cool, right? How to deploy BootStrap? Use JekyllBootStrap!

Download JekyllBootStrap into your page folder.
Modify content in "_config.yml" to your profile information.
Try run jekyll on your machine under the project folder.
jekyll serve
Much better, but still bad looking? How to beautify it?
Try cooler BootStrap icon nav-bar or modify it to transparent with a background image for your page!
Put following code into file "/assets/themes/twitter/css/style.css" to make your nav bar transparent
.navbar {
background-color: transparent;
background: transparent;
}
.navbar-inner {
background:transparent;
}
.navbar li { color: #000 }
Then modify your page with a background image! File location: "/assets/themes/twitter/css/style.css"
body {
background-image: url('YOUR_IMAGE_RELATIVE_PATH_UNDER_PROJECT_FOLDER');
background-size: inherit;
}
You can also modify the navi-bar information in "_includes/themes/twitter/default.html" For me, I modify it with

Archive

Categories

Pages

Tags

About

where about.html is rendered from about.md I write under the project root folder.
Now, try to write new post! New a file with name format "YYYY(YEAR)-MM(MONTH)-DD(DAY)-YOUR-PAGE-NAME-WITH-BLANK-REPLACED-BY-HYPHEN" under folder "_posts", with format
---
layout: post
category: [YOUR CATEGORY]
tags: [YOUR TAGS]
---
MAKR DOWN CONTENT
I'll recommend a great tool Dillinger to write MarkDown file! You can preview your MarkDown file online, similar to latex previewer WriteLatex.
Build your page with beatiful BootStrap css class, just by referring BootStrap.
If you want to write latex math formula on your page, try MathJax! You can just put following code into the header of html file "_includes/themes/twitter/default.html".

Now try MathJax " \$ \$ s = e ^{x+1} \cdot \frac {1}{1+e^x} \$ \$ " (remove space between dollar sign), you'll get $$ s = e ^{x+1} \cdot \frac {1}{1+e^x} $$.
For more about Math Block, click here
Notice: Github.io page no longer supports maruku markdown interpreter, try to add "markdown: kramdown" in "_config.yml" file to modify default markdown interpreter to Kramdown. : )
Get your code Syntax Highlighted in Github style
Add or modify pygments and highlighter to the following value:
pygments: true
highlighter: pygments
Include syntax.css in the html header in "_includes/themes/twitter/default.html" file.
<link rel="stylesheet" href="/css/syntax.css" type="text/css" media="screen" />
Now, try some code! (remove the backslash)
| \{\% highlight LANGUAGE_HERE linenos=table \%\}
Your Code Here
\{\% endhighlight \%\}
|
Big cong! Your blog has been set up!
Enjoy!
SIYONG MA
blog comments powered by Disqus


Humans have been intrigued by the question of whether life exists out there since our inception. That fundamental curiosity inspired great people to go where no man has gone before. Venus is one such planet which is worth the visit. Venus has super high-temperature and super-rotation density layers, where winds speeds are 60 times the speed of the rotation of the earth. Despite the harsh conditions on the surface, things are similar to earth-like conditions just about 50 km above surface level. Hence, the upper atmosphere is a suitable place for conducting science experiments. A Balloon based Satellite with IMUs and other sensors could help discover the unknowns of Venus. A lander(KRAGON) will investigate the surface and act as a wagon for the onboard rover(KRAWLER) which will explore further. Developing a proof of concept on Earth would be ideal to prototype and test the systems before arriving on Venus.
The on board flight computer is built with fault tolerant design philosophy. It performs data logging of 10 channel stream at 30 times per second. The software design utilized a state based system where the computer is aware of the flight stages. More features: Killswitch, Apogee Detection, Safety Net.
Rocket motors are the next critical element which requried a lot of testing. The thrust bench uses a loadcell to measure the rocket motor's thrust. Later impulse, specific impulse and avgerage force are calculated. The software is designed keeping safety in mind.
Developing rocket motors is truely the most difficult part of this endevour. This required a thrust bench to get thrust data to iterate rocket motor designs. After over 12 rocket motor builds, the motor design is now safe to use and performs as per design.
Data is the most important aspect in rocketry. Data can provide a picture perfect view of what happened during the flight. The on-board flight computer records data at 30 times/sec for 10 channels. This is plenty of data for post trajectory analysis, rocket strain and identifying anamolies.
Data is the most important aspect in rocketry. Data can provide a picture perfect view of what happened during the flight. The on-board flight computer records data at 30 times/sec for 10 channels. This is plenty of data for post trajectory analysis, rocket strain and identifying anamolies.
Data is the most important aspect in rocketry. Data can provide a picture perfect view of what happened during the flight. The on-board flight computer records data at 30 times/sec for 10 channels. This is plenty of data for post trajectory analysis, rocket strain and identifying anamolies.


| 1 | /** | |
| 2 | * Copyright (c) 2016-present, RxJava Contributors. | |
| 3 | * | |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in | |
| 5 | * compliance with the License. You may obtain a copy of the License at | |
| 6 | * | |
| 7 | * http://www.apache.org/licenses/LICENSE-2.0 | |
| 8 | * | |
| 9 | * Unless required by applicable law or agreed to in writing, software distributed under the License is | |
| 10 | * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See | |
| 11 | * the License for the specific language governing permissions and limitations under the License. | |
| 12 | */ | |
| 13 | ||
| 14 | package io.reactivex.rxjava3.subjects; | |
| 15 | ||
| 16 | import io.reactivex.rxjava3.annotations.*; | |
| 17 | import io.reactivex.rxjava3.core.*; | |
| 18 | ||
| 19 | /** | |
| 20 | * Represents an {@link Observer} and an {@link Observable} at the same time, allowing | |
| 21 | * multicasting events from a single source to multiple child {@code Observer}s. | |
| 22 | *
 | |
| 23 | * All methods except the {@link #onSubscribe(io.reactivex.rxjava3.disposables.Disposable)}, {@link #onNext(Object)}, | |
| 24 | * {@link #onError(Throwable)} and {@link #onComplete()} are thread-safe. | |
| 25 | * Use {@link #toSerialized()} to make these methods thread-safe as well. | |
| 26 | * | |
| 27 | * @param <T> the item value type | |
| 28 | */ | |
| 29 | public abstract class Subject<T> extends Observable<T> implements Observer<T> { | |
| 30 | /** | |
| 31 | * Returns true if the subject has any Observers. | |
| 32 | *
The method is thread-safe. | |
| 33 | * @return true if the subject has any Observers | |
| 34 | */ | |
| 35 | @CheckReturnValue | |
| 36 | public abstract boolean hasObservers(); | |
| 37 | ||
| 38 | /** | |
| 39 | * Returns true if the subject has reached a terminal state through an error event. | |
| 40 | *
The method is thread-safe. | |
| 41 | * @return true if the subject has reached a terminal state through an error event | |
| 42 | * @see #getThrowable() | |
| 43 | * @see #hasComplete() | |
| 44 | */ | |
| 45 | @CheckReturnValue | |
| 46 | public abstract boolean hasThrowable(); | |
| 47 | ||
| 48 | /** | |
| 49 | * Returns true if the subject has reached a terminal state through a complete event. | |
| 50 | *
The method is thread-safe. | |
| 51 | * @return true if the subject has reached a terminal state through a complete event | |
| 52 | * @see #hasThrowable() | |
| 53 | */ | |
| 54 | @CheckReturnValue | |
| 55 | public abstract boolean hasComplete(); | |
| 56 | ||
| 57 | /** | |
| 58 | * Returns the error that caused the Subject to terminate or null if the Subject | |
| 59 | * hasn't terminated yet. | |
| 60 | *
The method is thread-safe. | |
| 61 | * @return the error that caused the Subject to terminate or null if the Subject | |
| 62 | * hasn't terminated yet | |
| 63 | */ | |
| 64 | @Nullable | |
| 65 | @CheckReturnValue | |
| 66 | public abstract Throwable getThrowable(); | |
| 67 | ||
| 68 | /** | |
| 69 | * Wraps this Subject and serializes the calls to the onSubscribe, onNext, onError and | |
| 70 | * onComplete methods, making them thread-safe. | |
| 71 | *
The method is thread-safe. | |
| 72 | * @return the wrapped and serialized subject | |
| 73 | */ | |
| 74 | @NonNull | |
| 75 | @CheckReturnValue | |
| 76 | public final Subject<T> toSerialized() { | |
| 77 |
3
1. toSerialized : negated conditional → NO_COVERAGE 2. toSerialized : removed conditional - replaced equality check with false → NO_COVERAGE 3. toSerialized : removed conditional - replaced equality check with true → NO_COVERAGE |
if (this instanceof SerializedSubject) { |
| 78 |
2
1. toSerialized : replaced return value with null for io/reactivex/rxjava3/subjects/Subject::toSerialized → NO_COVERAGE 2. toSerialized : mutated return of Object value for io/reactivex/rxjava3/subjects/Subject::toSerialized to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return this; |
| 79 | } | |
| 80 |
3
1. toSerialized : removed call to io/reactivex/rxjava3/subjects/SerializedSubject::<init> → NO_COVERAGE 2. toSerialized : replaced return value with null for io/reactivex/rxjava3/subjects/Subject::toSerialized → NO_COVERAGE 3. toSerialized : mutated return of Object value for io/reactivex/rxjava3/subjects/Subject::toSerialized to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return new SerializedSubject<>(this); |
| 81 | } | |
| 82 | } | |
Mutations | ||
| 77 |
1.1 2.2 3.3 |
|
| 78 |
1.1 2.2 |
|
| 80 |
1.1 2.2 3.3 |


{% extends "base.html" %} {% block content %}
Method BulkEnvelopes::createBulkSendList creates a bulk send list that you can use to send an envelope to up to 1,000 recipients at once
{% if show_doc %}Documentation about this example.
{% endif %}API method used: Envelopes::createRecipient, Envelopes::createEnvelope, BulkEnvelopes::get, Envelopes::createCustomFields, BulkEnvelopes::createBulkSendList
View source file {{ source_file }} on GitHub.
{% endblock %}


The checkout process has been redesigned from scratch and greatly improved. You can now get to the card twice as fast and this leads to a much better user experience.
Streamlined onboarding process
The user onboarding process has been redefined and improved. Getting a user to sign up now requires fewer steps than before and the whole experience is simply better.
Simplified entry workflow
It's now easier than ever to add new database entries. We've just upgraded our platform and we're seeing 3x increases in speed and reliability.


{{template "stinger" .View}}
Compassionate Care Mobile Health will provide medical services, psychiatric services, and social services. Medical services available will include primary care services, such as disease education and management, prescription refills, basic wound care, and immunizations. A psychiatrist will be available to provide assessment and treatment, including prescription refills, for individuals with mental illness. Social workers will be available to ensure patients are educated on available resources and to provide assistance enrolling in appropriate programs. These programs may include enrolling in medical benefits, drug and alcohol rehab, securing housing, and access to food.
We plan to use our program design to provide consistent access to basic healthcare needs to individuals within our communities who would otherwise utilize Emergency Rooms for routine needs, or delay seeking medical attention until simple ailments turn in to devastating situations. Compassionate Care Mobile Health will provide a consistent face of medicine to those within our communities, enabling us to establish rapport and build trust with individuals who often feel abandoned and alone. Our goal is that with this relationship we build with them, we can transition these individuals to primary care physicians once they are established with a funding source. Our vision is a long-term solution to the epidemic that is affecting hospitals nationwide and we are certain that is something we can achieve.
Our mission is to give proper medical care to people who society has neglected despite their great need, with an acute focus on those passing through various stages of homelessness. Our hope is that through exposure, education and compassion - this beautiful mission will inspire our recipients to revere their health and stay well. Finally, our wish is for this project to induce holistic healing; a mobile clinic people can visit to find peace through the power of medical sciences, dignity and love.


How to write an engaging story
The story is a core component of the app and needs to be equally compelling and informative. It should give
a good introduction to a topic of choice, e.g.,
-
History: Make students relive historical situations, or teach them about important events
from an immersive perspective
-
Ethics: Pose ethical dilemmas to your students and discuss the results in class
-
Economics: Write a branching story that shows students how certain decisions, such as raising
the base interest rate, affects daily live
From our own personal experience, we derived a 6-step guide on how to write an engaging story:
-
Don't give too much thought about an overly specific topic. It is easier to embed your story
in one big background, such as World War I, instead of, for example, the Yalta Conference.
-
Make clear in advance which facts you want to convey. Resources like
Lemo,
bpb or
Wikipedia can help you to get an initial overview. Don't overdo it with the facts, your story
shouldn't be a mere list of historical events in the end
-
Think of a framing storyline. It's best to divide the story into acts or scenes, and arrange
them into an arc of tension. Be inspired by things you've read, heard or seen lately. TV series in
particular have mastered the art of keeping up tension.
-
Add your facts from your earlier research to the scenes and think about which emotions fit.
Write a short exposé for each scene. This helps you to visualize the plotline. If you have a partner, ask him or her to help
you write the dialogues. A conversation can be better conceived in pairs if different roles can be
assumed. Dialogue is not a must, though. You can write everything from a ferst person-view and describe
the thought world of the protagonist.
-
If you have multiple scenes with a stringent story, you can think about how to build different story
branches.
Paint the story as a tree of decisions to keep track of the story (and help you connecting
them later in the interface). Limit yourself to two options per story block, otherwise, the tree
branches too far out and it's hard to keep track of the different paths. Let the different options
end up int he same end again. This way you can ensure that everyone has the same information at the
end. With more preparation time you can also build sophisticated branched story
-
Read everything again at the end and be honest with yourself if you enjoy following the story.
Don't be afraid to ask for help. Not everyone is born a Hemingway, but as a teacher you should learn something
new every day. If you need a primer to get started on writing, read this
article from The Guardian, which gives tips to aspiring writers. Also, if you should take a liking
to writing fiction, take a look at Stephen King's
Twenty Rules for Writers—he didn't become the Master of Suspense for nothing.
One more tip: creating a new story block whenever you usually want to create a new paragraph makes your
story more immersive. Just create a block where both reactions lead to the same next ID – boom! An illusion
of choice is created.
Further resources
Here are some more resources for all your writing needs:
Photos and pictures
-
Pexels
is an excellent resource for CC0-licensed pictures which you are free to use in any way you like
-
TheStocks
is a page where you can find a myriad of photos, graphics and illustrations. Not all of them are
CC0, though, so be sure to check the license!
Writing and planning
-
On Writing Well
is a great book which guides you not only through the process of writing, but also through research
for your texts
-
Stephen King's A Memoir of the Craft
is a great read and full of tips on how to improve your writing style
-
Draw.io
is a tool which helps you to create flow charts, so you won't lose track of your story. We personally
prefer pen and paper, but maybe a software might be the better approach of you're constantly changing
the names of your blocks


The Integrated Development Environment (IDE) documented here lets you write Z80 assembly language and see it running within a few milliseconds on a TRS-80 emulator.
The code is on the left, the emulator is on the right, and the pull-down menu is on top. As you type into the editor, the code is assembled on the fly. The machine language bytes are shown on the left next to each line. With every re-assembly, the TRS-80 emulator on the right is wiped clean, brought to a known state, and your program is loaded and run.
Try this simple program:
.org 0x8000 ld hl,15360 ld a,191 ld (hl),a stop: jp stop
The stop label must be in the first column, the rest must not be in the first column, and the indent is typically 8 spaces. It loads at 0x8000 (the start of the top 32K of RAM) and puts a graphic character block at the top-left of the screen. You should see this block appears as soon as you've finished typing the program. Try changing the character (191) to different values and watch the emulator update.
In TRS-80 programs, screenshots such as splash screens and game mazes are often hard-coded into the assembly language code using a sequence of byte statements, like this:
.byte 0x87,0x8B,0x8C,0x8C,0x8C,0x8C,0x83,0x83 .byte 0x83,0x89,0x8C,0x8C,0x8C,0x8C,0x8C,0x8C
These are tedious to write and edit. To simplify making these, the IDE provides a built-in paint program. Simply mark your bytes with these start and end comments:
; Screenshot .byte 0x87,0x8B,0x8C,0x8C,0x8C,0x8C,0x83,0x83 .byte 0x83,0x89,0x8C,0x8C,0x8C,0x8C,0x8C,0x8C ; End screenshot
A EDIT button will appear to the right of the Screenshot comment. Click it to launch the paint program, which will replace the emulator's screen on the right. Click and drag in the screen to paint. Above the screen are various standard paint tools, most of which should be self-explanatory. Hover over each tool to see a hint about what it does.
To save the painted screen back into the source code, click the check mark button. To cancel, click the circle-with-a-slash button to the right of it.
The coordinates shown below the screen can be useful when constructing screens. Hold the Shift key while dragging out a new line, rectangle, or ellipse to get 45-degree lines, squares, or circles. The copy button not only copies the screen (or selected area) for later pasting within the paint program, but also copies an image of the area to your system clipboard for pasting into other applications.
The program has infinite undo/redo, so don't be afraid to experiment!
The assembler attempts to handle the union of all past Z80 assembler syntaxes. For example, it handles both org and .org directives. For numeric literals in non-decimal bases, it handles C-style prefixes (0x3C00, 0b10001010), assembler-style prefixes ($3C00, %10001010), and assembler-style suffixes (3C00h, 10001010b).


Simple library for Facebook Login.
Facebook SDK methods are wrapped in promises for better using. You may use Callback or Promises approach. You don't need to check if user logged out to run login method or check if user logged in to run logout method.
There are just three simple methods:
And you may run these methods in order you like. Outputed object has the following properties:
Connected: unknown
* open browser console to see outputs. Use window.facebook object in browser console for testing purposes
import facebook from '../src/index.js'; //setup your Facebook App const params = { appId: '260170667658655' }; /* === Callback approach === */ //check Facebook login results in callback method function callback(result) { console.log(result); const process = result.loading ? 'loading...' : ''; const connected = result.status === 'connected'; const user = result.data ? `your logged as ${result.data.first_name}` : ''; document.getElementById('connected').innerHTML = connected; document.getElementById('process').innerHTML = process; document.getElementById('user').innerHTML = user; } function cLogin() { facebook.callback.login(params, callback); } function cLogout() { facebook.callback.logout(params, callback); } function cCheckStatus() { facebook.callback.checkStatus(params, callback); } /* === Promises approach === */ // [TODO]


011-11113456
TOY CITY
Cart
Search
Main Menu
Toggle navigation
Home
Shop
Pages
Shop
Checkout
Cart
Pages
Introduction
About Us
FAQ
Dashboard
User Interface
Orders
Profile Details
Utility
Login Page
Signin Page
Order
Home
my account
Orders
Profile Details


You have reached the iAPI repository.
Use the url /data_push to save annotations and /data_get to retrieve them.
The server only accepts post requests.


Validator Page
The phase between game selection and game initialization is Validation. This is a mandatory process, and games cannot be loaded without having every file checked. This is crucial to prevent crashes spurred by errors and exceptions.
As such, when a game type is selected in the lobby, a new All Files Display is created which validates each file individually. At initialization, the files preloaded from the Game Type are checked and their statuses are displayed. The icons for the file type, the equality sign, and the status displayed are all data-driven from ResourceBundles. In our project, these can be found in the fileStatuses and fileTypes packages which are in iconBundles.
If any files are deemed invalid, the user will be presented with a Multiple XML File chooser. This will allow the user to select any number of files and then submit them. The validator will accept the first valid file using a descending order, and if none are valid, then it will mark the files as invalid. Any given file exists in one of three enumerated states: Valid, Empty, Invalid.
Once all five files are marked as valid, a launch button will become enabled. Upon click, the desired Game View will be rendered. If for any reason, the user wants to leave the validation process and select a new game, the All Files Display can simply be exited out of.


Welcome to Remex.
Remex is a utility class style framework that can be used for rapid prototyping or as a starter stylesheet for a full site build.
Setup is easy. There are three methods:
Use the minified CSS directly from GitHub by adding the followin line to the head of your HTML document: https://raw.githubusercontent.com/richbachman/Remex/master/dist/css/remex.min.css
Download the project, and copy the minified css from the dist folder to your project.
Clone the project using git, and make any customizations you see fit.
If you decide to install Remex using option three, all size and color customizations can be made in the appropriate files in the /src/scss/variables directory.
Once customizations have been made, simply run "npm build" to build a new dist file with the minified CSS.
Thank you for taking the time to review this initial Alpha release. Please submit any feedback or feature requests to rb@richbachman.com


Asher tells us where it's at! cc @newrelic @sweetlew @Cook84Cook 4/22/2015, 7:42:27 AM Favs: 1 Retweets: 0 link


In mathematics and computer science, an algorithm is a finite sequence of well-defined, computer-implementable instructions, typically to solve a class of problems or to perform a computation.Algorithms are always unambiguous and are used as specifications for performing calculations, data processing, automated reasoning, and other tasks.
Brute force algorithm emphasis on solving problems in the most straight forward manner. It implies to use basic techniques to solve problems. In short these are simplest algorithms to be used. The simplicity costs in speed as this algorithm is comparatively slow in generating results. The best way is to use it with problems those are having small input size.
The basic idea of this method is to make programs based on dividing the size of problems. In each loop cut the problem in parts with constant factor and then process further in the same fashion. This is a fast algorithm
If you are searching of one efficient fast algorithm then dynamic programming is here. In this algorithm all focus is made on speed of execution even it costs memory space. Simply saying in this method space for time is sacrificed. The execution speed drastically reduces in this algorithm. This method is particularly useful to solve problems that those have overlapping sub problems.
SGreedy algorithm is a step based algorithm. In a greedy algorithm we analyze the problem in each step. Then use the best locally possible optimum solution to this particular step .Then the process repeats to all steps. It will lead to a globally optimal solution.
In backtracking we generate a solution and test. If this solution is satisfying all conditions then and then only we go for further subsequent solutions else we will take a back gear simply saying backtrack and select a different path of finding solution. This process continues until we get a final solution.
Sample forms text (for purpose of an example).
Below this Text represents ways of field to be filled up


EBD - Easton Bible DIctionary
Zeredathah
ZEREDATHAH
"ZEREDATHAH "a place in the plain of Jordan; the same as Zarthan (
2 Chronicles 4:17
;
1 Kings 7:46
). Here Solomon erected the foundries in which Hiram made the great castings of bronze for the temple.
"ZEREDATHAH "a place in the plain of Jordan; the same as Zarthan (2 Chronicles 4:17; 1 Kings 7:46). Here Solomon erected the foundries in which Hiram made the great castings of bronze for the temple.


Name
Desc
Add
Delete
Search
Sort
Save
Load Local
Load From Server
Pending Count
Completed Count
Task List


About me
Product Owner Testautomation and Testarchitekt
Love Java VM based Languages specially Scala
Lives in
Switzerland
Find me at GitHub
PS
this site use google analytics
Product Owner Testautomation and Testarchitekt
Love Java VM based Languages specially Scala
Switzerland
this site use google analytics


From Level 0 to Level 1
Refer to the previous question. How can we improve???
- performance
- scalability
- robustness
performance
A better algo: Inverted Index
Avg performance increase to ~ 20ns (with some optimization of MapReduce procedure, discuss later).
Max QPS increase to 50.
scalability
Use a dispatcher to re-direct the requests to multiple machines.
How many machines do we need then?
Well we need 500 QPS. The algo above achieves ~ 50 QPS. Should we need 10 machines?
The answer is NO. A machine with 8 (or 16) core CPU could be able to handle.
We can also have a hot-standby, to be safe.
hot standby is used as a failover mechanism to provide reliability in system configurations.
When a key component fails, the hot spare is switched into operation.
robustness
Tips about system design for senior engineers:
Draw 1 machine first. This machine can contains multiple datasets and run multiple processes.
On top of this machine, the interface layer is one single Manager process. The Manager is in charge of almost everything: handling data lost, handle high concurrency, copy multiple instance of itself…
Like this:
Back-end
Now we need a cluster of datasets (which has Manager on top of it), and a cluster of Recommenders. Manager is in charge of copying multiple instances.
Dataset can be put in different physical locations. Recommender don’t really need, cuz it’s only do calculation job.
Receiving requests
Just now we used Receptionist (or Dispatcher) to handle request. Now we use a Web service (eg. Apache). It’s not necessary to make it a cluster.
Big Brother
We need a monitor system to oversee everything.
Also, Big Brother is in charge of heart-beat. If not received, Big Brother have some double-check machanism.
Connecting the dots
Dispatcher is used to connect the 4 components. It’s like a messaging queue that collects and distributes jobs among everybody (eg. control and distributed info).
It can be stateful or stateless.
Keep in mind the connection between Dataset and Recommender remains. It’s slow going thru Dispatcher.
Distribute it
During development, the 5 components can be put on same machine. When we deploy distributely, we use Socket connection (keep alive) to connect them.
Notice the Web Service is connection heavy, which consume large CPU and RAM resource. It’s better to seperate to one machine.
Big brother is read/write heavy, so it’s OKAY to put on same machine with Dispatcher.
Since Dataset and Recommender have data exchange, it’s a good idea to put on same machine.
Additional questions
Implement Dispatcher with consumer-producer model.