Hi there! I'm a curious human, researcher, and educator committed to answering interesting questions, building community, and designing thoughtfully. I earned my PhD in cognitive psychology from Duke University in 2021.
I was advised by Elizabeth Marsh. I also collaborate with Felipe De Brigard and Bridgette Martin Hard. My primary research questions are:
More below.
“For surely it is a magical thing for a handful of words, artfully arranged, to stop time. To conjure a place, a person, a situation, in all its specificity and dimensions. To affect us and alter us, as profoundly as real people and things do.”
The landscape of our memories is constructed from more than things that really happened. We also imagine worlds that never existed and people we've never met. I am fascinated by how and why we consume, remember, and share works of narrative fiction (such as books, movies, and TV shows). My work explores the ways that memories of fiction can be considered part of the autobiographical record.
How do we decide what to believe and remember? We consider novel forces that shape belief, including asymmetries in believing and unbelieving, the impermanance of qualifying language, and the weak contributions of reasons in changing people's minds. We also summarize findings from cognitive science, such as the theme that we are easily swayed by cognitive shortcuts and prior beliefs, for interdisciplinary audiences.
How can graphs mislead? We have largely ignored the potential contributions of graphs in generating and propagating misinformation. I am excited to say our research on this topic has only just begun. So far, we've focused on the effect of vertical axis truncation in bar graphs.
This project was spearheaded by Camila Vargas Restrepo when she was an undergraduate honors student in the Marsh Memory lab.
The business of learning and remembering is central to classrooms. Thus, one line of my work explores how the science of learning can be adapted and shared to students and teachers. I also work with Bridgette Martin Hard to study the scholarship of teaching and learning, merging excellent pedagogy with research on how best to teach and support students.
“Liberating education consists in acts of cognition, not transferals of information.”
I came to graduate school by way of being an educator. My teaching style is intentional, reflective, innovative, and joyful. I am experienced in developing student-centered curriculum differentiated for a wide range of skills, and centering classroom instruction on the lived realities of students. I am always seeking ways to grow. My goal in teaching is always to help students reveal their own potential to themselves.
I won the Duke University's Dean's Award for Excellence in Teaching in 2020.
2012 - 2015
I taught Anatomy & Physiology and Biology courses, developing and executing innovative, inquiry-based curricula. View student feedback from 2015.
2015
I developed and led an intensive (7 hours a day for 3 weeks), college-level cognitive psychology course for gifted youth grades 7 - 12. Students wrote extensively, researched and debated linguistic relativism, and wrote & illustrated a book of colloquially answered cognitive neuroscience "What if?" questions. View student feedback.
2015 - 2017
I served as a TA for Ruth Day (Psy102 Cognitive Psychology) and Mark Leary (Psy104 Personality Psychology).
2018 - 2019
I voluntered to coordinate two semesters of Introduction to Psychology (Psy101), along with Paula Yust. This included mentorship of 14 undergraduate teaching fellows (including observations and written feedback), developing formative and summative assessments, and managing communication with students.
Fall 2019
I designed and taught Cognitive Psychology (Psy242). This course contained a lab component and enrolled 24 students. Students wrote science communication pieces. View student perceptions of teaching: full report, with comparative info.
“Where we are born into privilege, we are charged with dismantling any myth of supremacy. Where we are born into struggle, we are charged with claiming our dignity, joy and liberation.”
Mentorship is one of the most important practices of science and a skill I take pride in cultivating. My goals in mentoring students and young researchers is to help them clarify and realize their own goals through rigor- and curiosity-driven engagement with the scientific process. One of my great joys is also mentoring and coaching others in teaching and pedagogy.
I believe that great mentors are not born, but made. During graduate school, I took concrete steps to help make excellent mentoring practices more accessible to all. This included, spearheading the creation of the department's first Mentoring Handbook.
In April 2019, I co-developed and co-led four, two-hour sessions focused on the fundamental principles of a good mentoring relationship as part of the Duke Institute for Brain Sciences (DIBS) ongoing Inclusion and Power Dynamics series. The workshops were planned and led in collaboration with Kendra Seaman, a post-doc at the time who is now faculty at UT Dallas.
How are you? I'm so happy you dropped by. I would love to hear from you. You can send me an email at my personal address: brendaya12 at gmail.com. Some reasons you might want to contact me include:
It would be my pleasure to write you a letter of recommendation. Please keep in mind that I won't have very recent knowledge of your academic or personal growth. If you still feel that a letter from me might help you succeed, please provide the following:


Read the data files from your own Pod or public data files from other's Pods.
You are able to create a new data file and add triples to the file. You can also search existing schema for your triples.
Post a data request with your research purpose, requested data elements, data usage period, the number of participants you need, and what type of analysis. Data request will be saved publicly in your own Pod.
View and search all data requests. By approving the data request, you give the "READ" access of your specific data file to the requester. You are able to indicate until when you want to participate in this study. Please note that you are always the owner of your data and have full control of your data.


@* * Copyright 2021 HM Revenue & Customs * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. *@ @import controllers.{routes, v2} @import models.{Case, Permission, StoredAttachment} @import models.request.AuthenticatedRequest @import utils.Dates @import views.html.partials.attachment @(id: String, attachments: Seq[StoredAttachment], showUploadedBy: Boolean = false, showSelect: Boolean = false, showRemoval: Boolean = false, caseRef: Option[String] = None, startAtTabIndex : Option[Int] = None )(implicit request: AuthenticatedRequest[_], messages: Messages) @if(attachments.nonEmpty){
| File | @if(showUploadedBy) {Uploaded by | } @if(showSelect) {Publish | }Date | attachment action |
|---|---|---|---|---|
| @attachment(s"$id-row-$index", file, useTabIndex = startAtTabIndex.map(x => x+1+(0*index))) | @if(showUploadedBy) {@file.operator.flatMap(_.name).getOrElse("Unknown") | } @if(showSelect) {
|
}
@Dates.format(file.timestamp) | @if(showRemoval && caseRef.isDefined && request.hasPermission(Permission.REMOVE_ATTACHMENTS)) {@messages("case.attachment.remove.file.hidden.text",file.fileName.getOrElse("New Attachment")) | }


Couple of weeks ago I attended to serverless course. I’ve played with lambdas from time to time (basically when AWS forced me to use them) but without knowing exactly what I was doing. After this course I know how to work with the serverless framework and I understand better lambda world. Today I want to hack a little bit and create a simple Python service to obtain random numbers. Let’s start
We don’t need Flask to create lambdas but as I’m very comfortable with it so we’ll use it here. Basically I follow the steps that I’ve read here.
from flask import Flask
app = Flask(__name__)
@app.route("/", methods=["GET"])
def hello():
return "Hello from lambda"
if __name__ == '__main__':
app.run()
And serverless yaml to configure the service
service: random
plugins:
- serverless-wsgi
- serverless-python-requirements
- serverless-pseudo-parameters
custom:
defaultRegion: eu-central-1
defaultStage: dev
wsgi:
app: app.app
packRequirements: false
pythonRequirements:
dockerizePip: non-linux
provider:
name: aws
runtime: python3.7
region: ${opt:region, self:custom.defaultRegion}
stage: ${opt:stage, self:custom.defaultStage}
functions:
home:
handler: wsgi_handler.handler
events:
- http: GET /
We’re going to use serverless plugins. We need to install them:
npx serverless plugin install -n serverless-wsgi
npx serverless plugin install -n serverless-python-requirements
npx serverless plugin install -n serverless-pseudo-parameters
And that’s all. Our “Hello world” lambda service with Python and Flask is up and running. Now We’re going to create a “more complex” service. We’re going to return a random number with random.randint function. randint requires two parameters: start, end. We’re going to pass the end parameter to our service. The start value will be parameterized. I’ll parameterize it only because I want to play with AWS’s Parameter Store (SSM). It’s just an excuse.
Let’s start with the service:
from random import randint
from flask import Flask, jsonify
import boto3
from ssm_parameter_store import SSMParameterStore
import os
from dotenv import load_dotenv
current_dir = os.path.dirname(os.path.abspath(__file__))
load_dotenv(dotenv_path="{}/.env".format(current_dir))
app = Flask(__name__)
app.config.update(
STORE=SSMParameterStore(
prefix="{}/{}".format(os.environ.get('ssm_prefix'), os.environ.get('stage')),
ssm_client=boto3.client('ssm', region_name=os.environ.get('region')),
ttl=int(os.environ.get('ssm_ttl'))
)
)
@app.route("/", methods=["GET"])
def hello():
return "Hello from lambda"
@app.route("/random/<int:to_int>", methods=["GET"])
def get_random_quote(to_int):
from_int = app.config['STORE']['from_int']
return jsonify(randint(from_int, to_int))
if __name__ == '__main__':
app.run()
Now the serverless configuration. I can use only one function, handling all routes and letting Flask do the job.
functions:
app:
handler: wsgi_handler.handler
events:
- http: ANY /
- http: 'ANY {proxy+}'
But in this example I want to create two different functions. Only for fun (and to use different role statements and different logs in cloudwatch).
service: random
plugins:
- serverless-wsgi
- serverless-python-requirements
- serverless-pseudo-parameters
- serverless-iam-roles-per-function
custom:
defaultRegion: eu-central-1
defaultStage: dev
wsgi:
app: app.app
packRequirements: false
pythonRequirements:
dockerizePip: non-linux
provider:
name: aws
runtime: python3.7
region: ${opt:region, self:custom.defaultRegion}
stage: ${opt:stage, self:custom.defaultStage}
memorySize: 128
environment:
region: ${self:provider.region}
stage: ${self:provider.stage}
functions:
app:
handler: wsgi_handler.handler
events:
- http: ANY /
- http: 'ANY {proxy+}'
iamRoleStatements:
- Effect: Allow
Action: ssm:DescribeParameters
Resource: arn:aws:ssm:${self:provider.region}:#{AWS::AccountId}:*
- Effect: Allow
Action: ssm:GetParameter
Resource: arn:aws:ssm:${self:provider.region}:#{AWS::AccountId}:parameter/random/*
home:
handler: wsgi_handler.handler
events:
- http: GET /
And that’s all. “npx serverless deploy” and my random generator is running.


Welcome to CMSC426
Computer Vision Spring 2019
This course offers an introduction to Computer Vision and Computational Photography. The course will cover basic principles of Image Processing, Multiple View Geometry for Visual Navigation, and Image Recognition using Classical and Deep Learning . It will explore the topics of image formation , image feature, image stitching, image and video segmentation, motion estimation, tracking, stereo, SLAM, and object and scene recognition.
The course is intended for anyone interested in processing images or video, or interested in acquiring general background in real-world perception. The course is , organized around a number of projects. Through these projects you will learn the theory and practical skills required in jobsof computer vision engineering.
Grading
- Projects 50 %
- Homework 25%
- MidTerm 20%
- Class Participation 5%
Prerequisites
Programming proficiency is the only hard pre-requisite. We recommend familiarity with Matlab. Furthermore, students taking the class should be comfortable with basic Linear Algebra and calculus.
Software
We will use MATLAB as the programming platform throughout this course, available to UMD students
through
.
Assignments
All projects are intended to be done in groups of upto 3. However, homeworks MUST be done individually.
Late Policy
We encourage students to submit in time.
Late are submissions are accepted for five days for a 20% reduction in points
Logistics
All class announcements will be made through Piazza . Please use Piazza to contact TAs, rather than email.
All projects and homeworks are to be submitted using ELMS .
.
Course Outcomes
- Knowledge of image formation process
- Knowledge of image processing techniques for color and gray level images: edge detection, corner detection, segmentation
- Basic knowledge of video processing, motion computation and 3D vision and geometry
- Basic Knowledge of applying machine learning for Recognition Tasks
- Ability to implement vision algorithms in Matlab
- Ability to write a project report and discuss the results
Collaboration Policy
Collaboration is encouraged, but one should know the difference between collaboration and cheating. Cheating may be defined as using or attempting to use unauthorized assistance, material, or study aids in academic work or examinations. Some examples of cheating are: collaborating on a take-home exam or homework unless explicitly allowed; copying homework; handing in someone else's work as your own; and plagiarism.
You are welcome to collaborate with your peers, but it's important that your work is an expression of *your* understanding, and not merely something you copied from a peer. So, we place strict limits on collaboration:
- You must clearly cite your collaborators by name at the top of your report. This includes Piazza posts referenced.
- You may not share or copy each other's code. You can discuss how your code works, and the concepts it implements, but you can't just show someone your code.
- For homeworks, when it comes to formulating or writing solutions, you must work alone. For example, if you're working with your peers on a common whiteboard, you may not simply copy from that whiteboard; you must write your answer separately, based on your own understanding of what you discussed.
You may use free and publicly available external sources (such as books, journal and conference publications, and web pages) as research material for your answers.
You may not use any service that involves payment, and you must clearly and explicitly cite all outside sources and materials that you made use of. We consider the use of uncited external sources as portraying someone else's work as your own, and as such it is a violation of the University's policies on academic dishonesty. We take this policy seriously: violations may result in a zero grade for the assignment, or even failing the course.
Unless otherwise specified, you should assume that that the
UMD Code of Academic Integrity applies.
Campus Policies
It is our shared responsibility to know and abide by the University of Maryland’s policies that relate to all courses, which include topics like:
- Academic integrity
- Student and instructor conduct
- Accessibility and accommodations
- Attendance and excused absences
- Grades and appeals
- Copyright and intellectual property
Please visit www.ugst.umd.edu/courserelatedpolicies.html for the Office of Undergraduate Studies’ full list of campus-wide policies and follow up with me if you have questions


[§489E-6] Construction and application. This chapter shall be construed and applied:
(1) To facilitate electronic transactions consistent with other applicable law;
(2) To be consistent with reasonable practices concerning electronic transactions and with the continued expansion of those practices; and
(3) To effectuate its general purpose to make uniform the law with respect to the subject of this chapter among states enacting it. [L 2000, c 282, pt of §1]


---
layout: page
title: "About"
description: "Hey, this is Qin."
header-img: "img/background-color.jpg"
---
Hello, this is Qin, a PhD candidate in CS, the George Washington University. My research interstes include mobile networks, IoT security and game theory.
I do exercise every day and I love cooking and video editing in my leisure time. I own a WeChat subscription named DailyEating. You can talk with me here.
Publications
Hu Q, Wang S, Bie R, et al. Social Welfare Control in Mobile Crowdsensing Using Zero-Determinant Strategy[J]. Sensors, 2017, 17(5): 1012.
Hu Q, Wang S, Ma L, et al. Anti-Malicious Crowdsourcing Using the Zero-Determinant Strategy[C]//Distributed Computing Systems (ICDCS), 2017 IEEE 37th International Conference on. IEEE, 2017: 1137-1146.
Hu Q, Wang S, Ma L, et al. Solving the crowdsourcing dilemma using the zero-determinant strategy: poster[C]//Proceedings of the 17th ACM International Symposium on Mobile Ad Hoc Networking and Computing. ACM, 2016: 373-374.
Hu Q, Wang S, Bie R, et al. Low Price to Win: Interactive scheme in cooperative cognitive radio networks[C]//Communications (ICC), 2015 IEEE International Conference on. IEEE, 2015: 7546-7551.
Wang S, Hu Q, Sun Y, et al. Privacy Preservation in Location-Based Services[J]. IEEE Communications Magazine, 2018, 56(3): 134-140.
Huang J, Hu Q, Bi J, et al. Stackelberg game based incentive mechanism for data transmission in mobile opportunistic networks[C]//International Conference on Wireless Algorithms, Systems, and Applications. Springer, Cham, 2016: 377-388.
Yao D, Zhang C, Zhu Z, et al. Learning deep representation for trajectory clustering[J]. Expert Systems, e12252.
{% if site.gitalk.enable %}


Abhishek Padmanabhan's Lab 4
First Name
Last Name
Email
Phone
Text Field
Age
18-35
36-50
51-65
Submit


241
你曾带我走过白日的喧嚣直到黑夜的寂静
我在沉默的夜里慢慢体会这段旅程的意义
The original：
Thou hast led me through my crowded travels of the day to my evening’s loneliness.
I wait for its meaning through the stillness of the night.
《飞鸟集》是泰戈尔老先生的作品。里面的诗歌隽永，优美而又充满哲理。每天翻译一首，愿与诸君共赏。
Stray Birds, written by Rabindranath Tagore, is a collection of poetic aphorisms, remarkable for their simplicity but resonating deeply with fundamental truths of being, life, love, and the marvels of our universe. I translate a poem form Stray Birds to Chinese every day, hope more and more people get to know Tagore’s great work.
This page is synchronized from the post: ‘《飞鸟与夏花》每天一首自译飞鸟集（241/325） - Translate a poem from Stray Birds every day’


Package to perform non-invasive fetal testing for aneuploidies using sequencing count data from cell-free DNA
| Version: | 0.1.1 |
| Depends: | R (≥ 3.1.1) |
| Imports: | data.table, Biostrings, Rsamtools, GenomicRanges, GenomicAlignments, PropCIs |
| Suggests: | BSgenome.Hsapiens.UCSC.hg19 |
| Published: | 2014-11-20 |
| Author: | Kitty Lo |
| Maintainer: | Kitty Lo <kitty.lo at ucl.ac.uk> |
| License: | GPL-3 |
| NeedsCompilation: | no |
| Materials: | NEWS |
| CRAN checks: | RAPIDR results |
| Reference manual: | RAPIDR.pdf |
| Vignettes: |
RAPIDR vignette |
| Package source: | RAPIDR_0.1.1.tar.gz |
| Windows binaries: | r-devel: RAPIDR_0.1.1.zip, r-release: RAPIDR_0.1.1.zip, r-oldrel: RAPIDR_0.1.1.zip |
| OS X binaries: | r-release: not available, r-oldrel: RAPIDR_0.1.1.tgz |
| Old sources: | RAPIDR archive |
Please use the canonical form https://CRAN.R-project.org/package=RAPIDR to link to this page.


Perspective Projection
Assignment Goals:
- Convert your orthographic projection interactive to use perspective projection.
Instructions for you to follow in this document will be highlighted in blue.
Don't forget to cite your sources!
How Vision Works
Orthographic projection doesn't reflect how we see things here in three dimensional space. With orthographic projection, the light rays we see travel parallel to each other. In reality, the light rays we see all pass through what is roughly a single point in our eyes.
You can see a comparison of orthographic and perspective cameras' view regions here. (use the O and P keys)
This makes the math a little bit trickier, since this is no longer a linear transformation, but we can avoid most of the complication by locating the camera at the origin. However, we do need to introduce a new concept: the image plane (or picture plane)
.
[Click to Toggle Animation]
- We locate our "eye" and the image plane within our 3d scene.
- For each vertex, we draw a line between that vertex and our "eye".
- Where that vertex strikes the image plane, we draw onto our canvas.
Complete the following:
- Given a point at coordinates (x,y,z), what are the coordinates of points along the line between it and the origin?
- Suppose our image plane is given by z = 1. What are the coordinates of the point along this line where it intersects our plane?
You can also work out the coordinates using similar triangles:
- Copy your html file from the previous activity on orthogonal projection.
- Write a function
project(v)
which takes in a THREE.Vector3 and returns a new THREE.Vector3 with the coordinates of the intersection point you figured out.
Recall:
- To create a Vector3, use the code
new THREE.Vector3(x,y,z)
- You can get the contents of a Vector3
v
using v.x
, v.y
, and v.z
, or get the whole thing as an array with
v.toArray()
- Copy your
draw_ortho
function to create a draw_persp
which applies project
before drawing.
- Replace any calls to
draw_ortho
with calls to draw_persp
in your HTML.
- At this point, your drawing (whether of the cube or the bunny) should look entirely incorrect. The issue is that our 3d models are centered around the origin, where our "eye" is, and we're actually seeing vertices that are "behind" our "eye" being projected onto the image plane.
- Fix this by shifting every point in your model in the z direction. For the cube, you'll want to shift by at least 1.8 units. For the bunny, you'll want to shift by at least 7 units. If
v
is a THREE.Vector3, then you can add another vector w
to it with v.add(w)
. The more you shift, the less distorted the image will look, but it will also look smaller. You can make it larger by adjusting your convert_x_graph_to_canvas
and convert_y_graph_to_canvas
functions.
Real 3d renderers only draw lines and planes within a specific region. You can see these regions visualized
here. (Use the O and P keys to switch between orthographic and perspective projections.) These camera regions are called viewing frustums. While it's easy enough to detect if a vertex is within these regions or not, we would need to cut our lines and triangles off when they leave the camera region, which is easy but a nuisance.
Above and Beyond
The following improvements are optional.
- Add controls to adjust the z-coordinate of the image plane, the translation vector, and the scaling factor in
convert_x/y_graph_to_canvas
.
- Implement the above mentioned cutting off of lines. Instead of drawing a line between two points P1 and P2, if P1 has a positive z coordinate and P2 has a negative z coordinate, solve for P3 where on the line z switches from positive to negative and only draw the line between the projections of P1 and P3.
- Locate some small .obj files online and convert them into javascript lists to use in your interactive. If you open them with a text editor, the lines starting with v represent vertices and lines starting with f represent faces. You can ignore other lines such as those starting with vn which represent vertex normals: directional information used for lighting.
Don't forget to cite your sources and be careful about licensing!


Tiles Updated
Here's what's new in 2.0.0:
- Change the background color from options
- Tiles scale better to different window sizes
- Several bug fixes and speed improvements
Restart Chrome if you experience any issues.
If issues persist, get support at our website.


{% extends "_base.html" %} {% block style %} {{ super() }} body { /*font: 10px sans-serif;*/ } .axis path, .axis line { fill: none; stroke: #000; stroke-width: 2px; shape-rendering: crispEdges; } {% endblock style %} {% block bodycontent %}
This graph shows recorded status history of packages tracked by the {{ config['name'] or '' }} portingdb.
{% if expand %} You can make the graph show percentages or counts. {% else %} You can make the graph show percentages or counts. {% endif %}
(Note that the exact methodology of assigning status to packages is evolving over time; for example the "mispackaged" status was added at the end of January 2016.)


To follow along, load this in your browser: https://www.ryanpatrickrandall.com/talks/comm101.html
Created by Ryan P. Randall
I'm here to help you prepare for your next assignment. And the rest of your classes, to be honest.
You know that sources aren't all the same.
So what makes sources different?
Where do these sources go on our timeline?
By the way, SUNY Canton has a great chart on the different "Types of Information Sources".
Let's imagine you're researching a recent event.
Let's watch UNLV's "Information Life Cycle" video!
Blakeslee, S. (2004). The CRAAP test.
The CRAAP criteria help you choose where to place your time & trust. There is no simple litmus test.
Blakeslee, S. (2004). The CRAAP test.
Here's some great places to start!
Even better than Google Scholar!
How did this go? Let me know at https://bit.ly/cwilif!
Please schedule an appointment with a CWI Librarian if you'd like further research assistance.
You can also get help from the College of Western Idaho Libraries through our online chat, our FAQ pages, calling or texting us, and email!
Thank you for your time!
"Pulling a book off the shelf" photo by Bennington College's Crossett Library with a CC BY-NC-SA 2.0 license.
Caulfield, Mike. SIFT (The Four Moves). Retrieved from SIFT (The Four Moves).
Blakeslee, S. (2004). The CRAAP test. LOEX Quarterly, 31(3), 6-7. Retrieved from https://commons.emich.edu/loexquarterly/vol31/iss3/4/.
"Purpose" photo by Seth Sawyers with a CC BY 2.0 license and given some minimal filtering by Ryan.


Enter text in the first box, and click to see it run.
set i 0 while {< &i 10} { puts "i is $i" incr &i }


@*Conteudo aqui - carregado pelo angularjs - atraves do ui-view*@
@* * This template is called from the `index` template. This template * handles the rendering of the page header and body tags. It takes * two arguments, a `String` for the title of the page and an `Html` * object to insert into the body of the page. *@


Toggle navigation
edify
Music
Home
About
Help
Sample Songs
Ode to Joy
Menuet
Cooley's
Prelude
National Anthems
Ghana
Liberia
Type or paste an abc tune in the area below and see it rendered as you type. Also notice that you can click on the drawn notes and see the place in the text where that note is defined.
×
Upload ABC notation text file:
Download as text file.


--- layout: post title: Viewtiful Joe 2 is out. date: 2004-12-07 00:00:00 ---
Viewtiful Joe 2 is out. I'm not a massive gamer, but was struck by the originality of the original when Mr Melon showed me it a while back - it seemed like a textbook example of using the ever-increasing capabilities of a games console to do something really new...


--- layout: single ---
Currently a tenure-track associate professor in National Laboratory of Radar Signal Processing, Xidian University, I am working on various applications of computational imaging including radio interferometry, radar, etc. In this context, my research focuses on inverse problem, compressed sensing, machine learning and optimization.
Prior to joining Xidian University, I received the B.S. degree in Electronics Engineering from Xidian University, Xi'an, China, in 2011, both of the M.Eng. degree (Diplôme d’Ingénieur) and the M.Res. degree in image processing from IMT Atlantique (ex-Télécom Bretagne), Brest, France, and the Ph.D. degree in Astronomy and Astrophysics from Universié Paris-Sud, Orsay, France, in 2014 and 2017, respectively. My Ph.D. thesis was supervised by Dr. Jean-Luc Starck. I was a scientist (post-doc) in Signal Processing Laboratory 5 (LTS5), EPFL from 2017 to 2020, where I worked on inverse problem for radio interferometry with Prof. Jean-Philippe Thiran and Prof. Yves Wiaux.


Big Arrays, Fast: Profiling Cloud Storage Read Throughput¶
Introduction¶
Many geoscience problems involve analyzing hundreds of Gigabytes (GB), many Terabytes (TB = 100 GB), or even a Petabyte (PB = 1000 TB) of data. For such data volumes, downloading data to personal computers is inefficient. Data-proximate computing, possibly using a parallel computing cluster, is one way to overcome this challenge. With data-proximate computing, a user access a remote computer which is connected tightly to shared, high-performance storage, enabling rapid processing without the need for a download step.
Figure from Data Access Modes in Science, by Ryan Abernathey. http://dx.doi.org/10.6084/M9.FIGSHARE.11987466.V1
The cloud offers many exciting new possibilities for scientific data analysis. It also brings new technical challenges. Many scientific users are accustomed to the environments found on High-Performance Computing (HPC) systems, such as NSF’s XSEDE Computers or NCAR’s Cheyenne system. These systems combine parallel computing with a high-performance shared filesystem, enabling massively parallel data analytics. When shifting workloads to the cloud, one of the biggest challenges is how to store data: cloud computing does not easily support large shared filesystems, as commonly found on HPC systems. The preferred way to store data in the cloud is using cloud object storage, such as Amazon S3 or Google Cloud Storage.
Image via Ubuntu Website, ©2020 Canonical Ltd. Ubuntu, Used with Permission
Cloud object storage is essentially a key/value storage system. They keys are strings, and the values are bytes of data. Data is read and written using HTTP calls. The performance of object storage is very different from file storage. On one hand, each individual read / write to object storage has a high overhead (10-100 ms), since it has to go over the network. On the other hand, object storage “scales out” nearly infinitely, meaning that we can make hundreds, thousands, or millions of concurrent reads / writes. This makes object storage well suited for distributed data analytics. However, the software architecture of a data analysis system must be adapted to take advantage of these properties.
The goal of this notebook is to demonstrate one software stack that can effectively exploit the scalable nature of cloud storage and computing for data processing. There are three key elements:
Zarr - a library for the storage of multi-dimensional arrays using compressed chunks.
Filesystem Spec - an abstraction layer for working with different storage technologies. Specific implementations of filesystem spec (e.g. gcsfs, Google Cloud Storage Filesystem) allow Zarr to read and write data from object storage.
Dask - a distributed computing framework that allows us to read and write data in parallel asynchronously.
Accessing the Data¶
For this demonstration, we will use data stored in Google Cloud Storage. The data come from the GFDL CM2.6 high-resolution climate model. They are catalogged on the Pangeo Cloud Data Catalog here:
The catalog returns an http://xarray.pydata.org/ object pointing to the data on google cloud:
import dask.array as dsa
import fsspec
import numpy as np
import pandas as pd
from contextlib import contextmanager
import pandas as pd
import intake
import time
import seaborn as sns
import dask
from matplotlib import pyplot as plt
from intake import open_catalog
cat = open_catalog("https://raw.githubusercontent.com/pangeo-data/pangeo-datastore/master/intake-catalogs/ocean/GFDL_CM2.6.yaml")
item = cat["GFDL_CM2_6_control_ocean"]
ds = item.to_dask()
ds
For this example, we are not interested in Xarray’s advanced data analytics features, so we will work directly with the raw array data. Here we examine the data from the temp
variable (ocean temperature):
data = ds.temp.data
data
Before dropping down to the dask level, we take a quick peek at the data using Xarray’s built-in visualization capabilities.
ds.temp[0, 0].plot(figsize=(16, 8), center=False, robust=True)
Side note: We can open this array directly with dask, bypassing xarray, if we know the path on the object store. (These give identical results.)
item.urlpath
dsa.from_zarr(fsspec.get_mapper("gs://cmip6/GFDL_CM2_6/control/ocean/temp"))
Some important observations:
The data is organized into 2400 distinct chunks–each one corresponds to an individual object in Google Cloud Storage
The in-memory size of each chunk is 194.4 MB
The chunks are contiguous across the latitude and longitude dimensions (axes 2 and 3) and span 5 vertical levels (axis 1). Each timestep (axis 0) is in a different chunk.
Zarr + Dask know how to virtually combine these chunks into a single 4-dimensional array.
Set Up Benchmarking¶
Now we want to see how fast we can load data from the object store. We are not interested in any computations. Here the goal is simply to measure read performance and how it scales. In order to do this, we employ a trick: we store the data into a virtual storage target that simply discards the data, similar to piping data to /dev/null
on a filesystem.
To do this, we define the following storage class:
class DevNullStore:
def __init__(self):
pass
def __setitem__(*args, **kwargs):
pass
This is basically a dictionary that forgets whatever you put in it:
null_store = DevNullStore()
# this line produces no error but actually does nothing
null_store['foo'] = 'bar'
Now let’s see how long it takes to store one chunk of data into this null storage target. This essentially measures the read time.
%time dsa.store(data[0, :5], null_store, lock=False)
Now we want to scale this out to see how the read time scales as a function of number of parallel reads. For this, we need a Dask cluster. In our Pangeo environment, we can use Dask Gateway to create a Dask cluster. But there is an analogous way to do this on nearly any distributed computing environment. HPC-style environments (PBS, Slurm, etc.) are supported via Dask Jobqueue. Most cloud environments can work with Dask Kubernetes.
from dask_gateway import Gateway
from dask.distributed import Client
gateway = Gateway()
cluster = gateway.new_cluster()
cluster
client = Client(cluster)
client
Finally we create a context manager to help us keep track of the results of our benchmarking
class DiagnosticTimer:
def __init__(self):
self.diagnostics = []
@contextmanager
def time(self, **kwargs):
tic = time.time()
yield
toc = time.time()
kwargs["runtime"] = toc - tic
self.diagnostics.append(kwargs)
def dataframe(self):
return pd.DataFrame(self.diagnostics)
diag_timer = DiagnosticTimer()
Do Benchmarking¶
We want to keep track of some information about our array. Here we figure out the size (in bytes) of the chunks.
chunksize = np.prod(data.chunksize) * data.dtype.itemsize
chunksize
And about how many workers / threads are in the cluster. The current cluster setup uses two threads and approximately 4 GB of memory per worker. These settings are the defaults for the current Pangeo environment and have not been explored extensively. We do not expect high sensitivity to these parameters here, as the task is I/O limited, not CPU limited.
def total_nthreads():
return sum([v for v in client.nthreads().values()])
def total_ncores():
return sum([v for v in client.ncores().values()])
def total_workers():
return len(client.ncores())
This is the main loop where we time a distributed read for different numbers of worker counts. We also keep track of some other metadata about our testing conditions.
diag_kwargs = dict(nbytes=data.nbytes, chunksize=chunksize,
cloud='gcloud', format='zarr')
for nworkers in [30, 20, 10, 5]:
cluster.scale(nworkers)
time.sleep(10)
client.wait_for_workers(nworkers)
print(nworkers)
with diag_timer.time(nthreads=total_nthreads(),
ncores=total_ncores(),
nworkers=total_workers(),
**diag_kwargs):
future = dsa.store(data, null_store, lock=False, compute=False)
dask.compute(future, retries=5)
client.close()
cluster.close()
df = diag_timer.dataframe()
df
df.plot(x='ncores', y='runtime', marker='o')
df['throughput_MBps'] = df.nbytes / 1e6 / df['runtime']
df.plot(x='ncores', y='throughput_MBps', marker='o')
df['throughput_MBps_per_thread'] = df.throughput_MBps / df.nthreads
df.plot(x='nthreads', y='throughput_MBps_per_thread', marker='o')
plt.ylim([0, 100])
Compare Many Results¶
Similar tests to the one above were performed with many different cloud storage technologies and data formats:
Google Cloud Storage + Zarr Format (like the example above)
Google Cloud Storage + NetCDF Format (NetCDF files were opened directly from object storage using
gcsfs
to provide file-like objects toh5py
)Wasabi Cloud + Zarr Format (A discount cloud-storage vendor)
Jetstream Cloud + Zarr Format (NSF’s Cloud)
Open Storage Network (OSN) NCSA Storage Pod + Zarr Format
The NASA ECCO Data Portal (data read using
xmitgcm.llcreader
)Various OPeNDAP Servers, including:
The UCAR ESGF Node TDS Server
NOAA ESRL PSL TDS Server
The results have been archived on Zenodo:
Despite the different sources and formats, all tests were conducted in the same basic manner:
A “lazy” dask array referencing the source data was created
A dask cluster was scaled up to different sizes
The array was “stored” into the
NullStore
, forcing all data to read from the source
Note: All computing was done in Google Cloud.
url_base = 'https://zenodo.org/record/3829032/files/'
files = {'GCS Zarr': ['gcloud-test-1.csv', 'gcloud-test-3.csv', 'gcloud-test-4.csv',
'gcloud-test-5.csv', 'gcloud-test-6.csv'],
'GCS NetCDF': ['netcdf-test-1.csv'],
'Wasabi Zarr': ['wasabi-test-1.csv', 'wasabi-test-2.csv', 'wasabi-test-3.csv'],
'Jetstream Zarr': ['jetstream-1.csv', 'jetstream-2.csv'],
'ECCO Data Portal': ['ecco-data-portal-1.csv', 'ecco-data-portal-2.csv'],
'ESGF UCAR OPeNDAP': ['esgf-ucar-1.csv', 'esgf-ucar-2.csv'],
'NOAA ESRL OPeNDAP': ['noaa-esrl-1.csv', 'noaa-esrl-2.csv'],
'OSN Zarr': ['OSN-test-1.csv', 'OSN-test-2.csv']
}
data = {}
for name, fnames in files.items():
data[name] = pd.concat([pd.read_csv(f'{url_base}/{fname}') for fname in fnames])
data['OSN Zarr']
fig0, ax0 = plt.subplots()
fig1, axs = plt.subplots(nrows=2, ncols=4, figsize=(20, 8))
palette = sns.color_palette('colorblind', len(files))
for (name, df), color, ax1 in zip(data.items(), palette, axs.flat):
for ax in [ax0, ax1]:
df.plot(kind='scatter', x='ncores', y='throughput_MBps',
s=50, c=[color], edgecolor='k', ax=ax, label=name)
ax1.grid()
ax1.set_title(name)
ax0.grid()
ax0.legend(loc='upper left')
fig0.tight_layout()
fig1.tight_layout()
Discussion¶
The figure above shows a wide range of throughput rates and scaling behavior. There are a great many factors which might influence the results, including:
The structure of the source data (e.g. data format, chunk size, compression, etc.)
The rate at which the storage service can read and process data from its own disks
The transport protocol and encoding (compression, etc.)
The network bandwidth between the source and Google Cloud US-CENTRAL1 region
The overhead of the dask cluster in computing many tasks simultaneously
The comparison is far from “fair”: it is clearly biased towards Google Cloud Storage, which has optimum network proximity to the compute location. Nevertheless, we make the following observations.
Zarr is about 10x faster than NetCDF in Cloud Object Storage¶
Using 40 cores (20 dask workers), we were able to pull netCDF data from Google Cloud Storage at a rate of about 500 MB/s. Using the Zarr format, we could get to 5000 MB/s (5 GB/s) for the same number of dask workers.
Google Cloud Storage Scales¶
Both formats, however, showed good scaling, with throughput increasingly nearly linearly with the size of the cluster. The largest experiment we attempted used nearly 400 cores: we were able to pull data from GCS at roughly 20 GB/s. That’s pretty fast! At this rate, we could process a Petebyte of data in about 14 hours. However, there is a knee in the GCS-Zarr curve around 150 cores, with the scaling becoming slightly poorer above that value. We hypothesize that this is due to Dask’s overhead from handling a very large task graph.
External Cloud Storage Providers Scale…then Saturate¶
We tested three cloud storage providers outside of Google Cloud: Wasabi (a commercial service), Jetstream (an NSF-operated cloud), and OSN (an NSF-sponsored storage provider). These curves all show a similar pattern: good scaling for low worker counts, then a plateau. We interpret this a saturation of the network bandwidth between the data and the compute location. Of these three, Jetstream saturated at the lowest value (2 GB/s), then Wasabi (3.5 GB/s, but possibly not fully saturated yet), then OSN (5.5 GB/s). Also noteworthy is the fact that, for smaller core counts, OSN was actually faster than GCS within Google Cloud. These results are likely highly sensitive to network topology. However, they show unambiguously that OSN is an attractive choice for cloud-style storage and on-demand big-data processing.
OPeNDAP is Slow¶
The fastest we could get data out of an OPeNDAP server was 100 MB/s (UCAR ESGF Node). The NOAA ESRL server was more like 20 MB/s. These rates are many orders of magnitude than cloud storage. Perhaps these servers have throttling in place to limit their total bandwidth. Or perhaps the OPeNDAP protocol itself has some fundamental inefficiencies. OPeNDAP remains a very convenient protocol for remote data access; if we wish to use it for Big Data and distributed processing, data providers need to find some way to speed it up.
Conclusions¶
We demonstrated a protocol for testing the throughput and scalability Array data storage with the Dask computing framework. Using Google Cloud as our compute platform, we found, unsurprisingly, that a cloud-optimized storage format (Zarr), used with in-region cloud storage, provided the best raw throughput (up to 20 GB/s in our test) and scalability. We found that the same storage format also allowed us to transfer data on-demand from other clouds at reasonable rates (5 GB/s) for modest levels of parallelism. (Care must be taken in this case, however, because many cloud providers charge egress fees for data leaving their network.) Combined with Zarr, all of the cloud object storage platforms were able to deliver data orders of magnitude faster than traditional OPeNDAP servers, the standard remote-data-access protocol for the geosciences.
Future Work¶
This analysis could be improved in numerous ways. In the future we would like to
Investigate other cloud-native storage formats, such as TileDB and Cloud-Optimized Geotiff
Perform deeper analysis of parameter sensitivity (chunk size, compression, etc.)
Explore other clouds (e.g. AWS, Microstoft Azure)
Finally, we did not attempt to assess the relative costs associated with cloud vs. on-premises data storage, as this involves difficult questions related to total cost of ownership. However, we hope these results are useful for data providers in deciding how to provision future infrastructure for data-intensive geoscience.
Notebook Reviews¶
Here we include the review of the original version of this notebook and our replies.
Review 1¶
Evaluation of the Contribution¶
Overall Recommendation (100%): 9 Total points (out of 10) : 9
Comments for the Authors¶
“Big Arrays, Fast: Profiling Cloud Storage Read Throughput” is a good quality and, most of all, interesting science meets computer science notebook. It addresses important issues relevant to this scientific arena. The problem statement, discussion and conclusions are all compelling and pertinent to this area of inquiry.
The most important criterion “does it run” is satisfied as I was able to run the notebook to completion on https://ocean.pangeo.io (though I could not run it on Binder for some reason, “KeyError: ‘GFDL_CM2_6_control_ocean’”).
The error has been corrected in the current version.
I especially liked this notebook for the following reason:
The “computational essay” aspect receives high marks for having expository prose and computation work together to build a logical conclusion.
Figures are generated inline with matplotlib
Figures are easy to understand and interesting (e.g., the set of throughput figures at the end of the notebook).
The xarray.Dataset meta data allows for inspection via the attributes and data representation icons.
Computational cells are small and intermixed with expository prose.
Problems with this notebook:
Quite a few distracting spelling errors: Benachmarks, analagous, simultaneouslly, slighly, saturdation
Unfortunately, JupyterLab has no spell checker, a feature I have obviously become to reliant upon.
A suggestion for improvement would be to include a reference section with HTML linked DOIs for further inquiry and background material, and perhaps also a future work section.
A future work section has been included.
Review 2¶
Evaluation of the Contribution¶
Overall Recommendation (100%): 8 Total points (out of 10) : 8
Comments for the Authors¶
the author should add to the discussion a reason for the choice of threads, cores and workers in the ‘do benchmarking’ section
This has been done
while the analysis is designed to provide a coarse grain view of the speed of zarr, it might be a valuable exercise to break the scales down to segments where they can be compared; e.g. of the four zarr tests, the n_cores scales vary from 0..400 (gcs), 0..60 (wasabi, jetstream) and 0..175 (osn) and thus these scales make it difficult to compare them when we do not have data past n_cores=60 and again n_cores=175
This a reasonable suggestion but beyond what we could accomplish in a brief revision period.
though the authors acknowledge the tests are not ‘fair’, indeed it would be more valuable to compare various configurations of netcdf to make such comparisons more easily interpretable
It’s not clear what other “configurations” of netCDF are being suggested here.
typo: change to “saturation” > We interpret this a saturdation of the network bandwidth between the data and the compute location.
Thanks, done.
the abstract should include “preliminary” to situate this work as in-progress and not a full quantitative exploration and assessment of accessing data
Given the combinatoric explosion of possible configuration choices, is a comprehensive “full quantitative exploration” even possible?
if at all possible the author should provide instructions for how to execute elsewhere outside the pangeo platform
We have included some new links to how to deploy dask in other environments.
licensing information as well as notebook requirements should also be provided with the notebook (or a link to the GH repo if one exists for the notebook)
This was all included in the original submission.


One night at an event, your homie handed you a set of light gloves to play with. You weren't sure why, but hey, they were dope! What ever happened to those? Or maybe you're just here because you saw gloving somewhere, and thought, hey, time to put these hands to good use. Whichever it is, you're in the right place.
Power, affordability and creativity come together in the eLite ezLite. We recommend you roll your fingers around in this awesome beginner set before upgrading to our specialty lights in the higher price ranges.
All of our Premium Glove Sets feature the eLite Chip line: the most trusted, durable and customizable lights on the market. The ezLite comes glover-ready out-of-the-box with 20 gorgeous colors to choose from, and 3 of the most popular flashing patterns among pro glovers. You can even dip your fingertips into the world of Conjuring with our premier ClickSwitch Technology.
Turn your gloving into magic with one of our favorite classic styles, "Conjuring." Click the video thumbnail (right) to see how it works in Munch's classic show, "Lust." You can use a simple ClickSwitch feature on the ezLite to choose 1 of the
3 modes to use for on/off functionality.


--- layout: post esbma_id: 3078 title: Foreign Keys date: 2014-03-14 12:00:00 keywords: mssql_to_sqlite teaser: SQLite has excellent support for foreign keys, including the ability to defer them until commit time, which I wish that SQL Server could do. ---
(This entry is part of a series. The audience: SQL Server developers. The topic: SQLite on mobile devices.)
Actually, it does. Since version 3.6.19, released in October 2009. Before the first iPad. Windows 7 was not quite out yet. Miley Cyrus was still Hannah Montana.
CREATE TABLE [to] (pk int PRIMARY KEY); CREATE TABLE [from] (other REFERENCES [to](pk) ); INSERT INTO [from] (other) VALUES (3);
Fair enough. It is easy to get the impression that SQLite still lacks support for foreign keys because the feature is [usually] turned off by default, to preserve backward compatibility.
To enable the enforcement of foreign key constraints, execute the following SQL statement, shortly after you open your SQLite database connection:
PRAGMA foreign_keys = 1;
I always use SQLite with foreign keys. In fact, I always open SQLite connections with a helper function which (1) opens the SQLite connection and (2) immediately executes the PRAGMA above.
Once you've got the feature turned on, foreign key support in SQLite is generally similar to what a SQL Server dev would expect. Full documentation is available on the SQLite website, but there are a few things worth highlighting.
SQLite supports simple foreign keys (with one column referencing one column), or composite foreign keys (with multiple columns referencing multiple columns).
SQLite does support ON DELETE and ON CASCADE.
SQLite allows a foreign key constraint to be deferred, which means that its enforcement is postponed until the transaction is committed. This is a handy feature that I really wish SQL Server had.
Zumero for SQL Server automatically syncs foreign key constraints. Microsoft Sync Framework does not.
So there.
:-)
PRAGMA foreign_keys = 1; Always.


APT PUPIL A film review by Steve Rhodes Copyright 1998 Steve Rhodes RATING (0 TO ****): ** 1/2
The old "Alfred Hitchcock Presents" television series was masterful at creating little, macabre stories packaged into self-contained 30-minute doses. It knew just how to take a simple story of seemingly ordinary people, who looked like our next-door neighbors, and make us wait for the ending punch. With a few diabolical flourishes, the show's conclusion would reveal the characters' hidden evil. Trimmed of its fat, APT PUPIL would have made an intriguing episode.
After director Bryan Singer's first mesmerizing and popular film, THE USUAL SUSPECT, his second has been widely anticipated. APT PUPIL, adapted by Brandon Boyce from the Stephen King novella, was Singer's choice for an attempt to repeat his first success.
In some ways an odd choice, the story has a paucity of material to work with. On the other hand, a Stephen King novel about the Holocaust certainly has lots of potential for shock value. For some reason Singer downplays the shock while asking his audience to wait an hour and a half before he lets the movie finally take off. For those with suitable patience the payoff is there, and the wait is made tolerable by a fascinating performance by Ian McKellen.
McKellen plays the part of an old Nazi concentration camp guard living in the United Sates under the name of Kurt Dussander. With bad skin and a scruffy beard, Dussander clutches his cigarettes in his grimy hands, smoking them down to the last gram of tobacco. His gruff voice hides a cauldron of atrocities, hidden deep in the inner reaches of his memory.
In a lackluster performance, Brad Renfro plays a bored but brightly inquisitive high school senior named Todd Bowden. Todd's history class has just finished their week on the Holocaust, but Todd is not ready to move on to other subjects. Obsessed, he researches the subject in the library until he tracks down a previously unknown Nazi guard (Dussander) living right in the town's midst.
Confronting Dussander with his crimes, Todd demands daily doses of death camp stories, or he will turn Dussander in to the police. Although there are a couple of cheap exploitation scenes of the killing of animals and a few spooky daydream scenes of concentration inmates, the movie is remarkable for its moderation. The script manages to make the Holocaust seem almost trite. The entire movie could be rewritten without that aspect and be remarkably unchanged. All they would need to do is have Dussander be a serial killer who hasn't harmed anyone in several decades.
The film, while eventually entertaining, takes little risks, following a formula you've seen many times before. It is worth seeing for Ian McKellen's work, but, if you are waiting for director Bryan Singer to demonstrate his brilliance again, you'll have to hope his third picture is a charm.
APT PUPIL runs 1:51. It is rated R for strong violence, sex, drug usage and profanity and would be fine for older teenagers.
Email<EMAIL_ADDRESS>Web: www.InternetReviews.com
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


--- layout: jsdoc title: "Home" jsdocNav: - Classes: - SeleniumAssistant - WebDriverBrowser --- Reference Docs Below is a list of all the reference documentation for this project. You can find links to these in the navigation drawer as well. Classes SeleniumAssistant WebDriverBrowser
Below is a list of all the reference documentation for this project. You can find links to these in the navigation drawer as well.


Bridget Crowley
Introduction
I am learning about Front-End Web Development through General Assembley
Education
Amherst College
- Bachelor of Arts Degree: Law, Jurisprudence, and Social Thought
Professional Histoy
- Project Manager- MetLife - 2015- Present
- Regional Program Coordinator- Learn Fresh Education- 2015- Present
- Legal Assistant - Travers Dombroski - 2013-2015
Extracurricular
Amherst College Women's Basketball
- Team Captain- 2012-2013
- Divison III National Champion- 2011
Volutneer Work
- The 3Point Foundation- 2013-2015
- A Better Chance- 2009-2013


This section of the assistant aims at investitaging past attacks.
- Manage Attacks
- Where the analyst can add attacks to its repository and describe the context of their occurence.
- Perform the RCA of an attack
- An interactive tool to help the Root Cause Analysis, it aims at finding contributors to the success of an attack.
- View Results
- The results are compiled in a list, the analyst can add a justification for each of his choice.


The linestring example shows how linestrings can be declared and used and shows some more algorithms. One of the important concepts of the Generic Geometry Library is that it is totally built upon the standard library, using the standard containers such as std::vector.
A linestring is, as explained elsewhere in this documentation, not much more than a vector of points. Most algorithms run on linestrings, but can also run on any iterator pair. And all algorithms on std::vector can be used on geometry::linestring.
This documentation illustrates the simplify algorithm and the intersection algorithm with some pictures.
The simplify algorithm simplifies a linestring. Simplification means that the less important points are removed from the line and that the points that are most important for the shape of a line are kept. Simplification is done using the well known Douglas Peucker algorithm. The library user can specify the distance or tolerance, which indicates how much the linestring should be simplified.
The blue line is the original linestring; the red line is the simplified line which has one point less. In geographical applications simplification can reduce a linestring to its basic form containing only 10% of its original points.
The intersection algorithm intersects two geometries which each other, delivering a third geometry. In the case of the example a linestring is intersected with a box. Intersection with a box is often called a clip. The image below illustrates the intersection.
The yellow line is intersected with the blue box. The intersection result, painted in red, contains three linestrings.
#include <algorithm>
#include <iostream>
#include <iterator>
#include <utility>
#include <vector>
#include <boost/geometry/geometry.hpp>
template<typename P>
inline void translate_function(P& p)
{
p.x(p.x() + 100.0);
}
template<typename P>
struct scale_functor
{
inline void operator()(P& p)
{
p.x(p.x() * 1000.0);
p.y(p.y() * 1000.0);
}
};
template<typename Point>
struct round_coordinates
{
coordinate_type m_factor;
inline round_coordinates(coordinate_type const& factor)
: m_factor(factor)
{}
template <int Dimension>
inline void round(Point& p)
{
coordinate_type c = boost::geometry::get<Dimension>(p) / m_factor;
int rounded = c;
boost::geometry::set<Dimension>(p, coordinate_type(rounded) * m_factor);
}
inline void operator()(Point& p)
{
round<0>(p);
round<1>(p);
}
};
int main(void)
{
using namespace boost::geometry;
linestring_2d ls;
ls.push_back(make<point_2d>(1.1, 1.1));
point_2d lp;
std::cout << dsv(ls) << std::endl;
box_2d b;
std::cout << dsv(b) << std::endl;
std::cout <<
"length: " <<
length(ls) << std::endl;
std::cout << "number of points 1: " << ls.size() << std::endl;
std::cout << "number of points 2: " << boost::size(ls) << std::endl;
std::cout <<
"number of points 3: " <<
num_points(ls) << std::endl;
point_2d p(1.9, 1.2);
std::cout << "distance of " << dsv(p)
<<
" to line: " <<
distance(p, ls) << std::endl;
std::cout << "distance: " << d << std::endl;
const double c[][2] = { {3.1, 3.1}, {4.9, 1.1}, {3.1, 1.9} };
std::cout << "appended: " << dsv(ls) << std::endl;
{
std::vector<point_2d> v;
std::cout
<< "as vector: "
<< dsv(v)
<< std::endl;
}
std::cout << "reversed: " << dsv(ls) << std::endl;
std::vector<point_2d> pv(ls.begin(), ls.end());
std::cout <<
"length: " <<
length(pv) << std::endl;
{
point_2d last = ls.back(), first = ls.front();
ls.push_back(last);
ls.insert(ls.begin(), first);
}
std::cout << "extra duplicate points: " << dsv(ls) << std::endl;
{
linestring_2d ls_copy;
ls = ls_copy;
std::cout << "uniquecopy: " << dsv(ls) << std::endl;
}
linestring_2d ls_simplified;
std::cout << "simplified: " << dsv(ls_simplified) << std::endl;
{
linestring_2d lscopy = ls;
std::for_each(lscopy.begin(), lscopy.end(), translate_function<point_2d>);
std::cout << "modified line: " << dsv(lscopy) << std::endl;
}
box_2d cb(point_2d(1.5, 1.5), point_2d(4.5, 2.5));
std::vector<linestring_2d> clipped;
std::vector<std::vector<point_2d> > vector_out;
std::cout << "clipped output as vector:" << std::endl;
for (std::vector<std::vector<point_2d> >::const_iterator it
= vector_out.begin(); it != vector_out.end(); ++it)
{
std::cout << dsv(*it) << std::endl;
}
std::cout << "Convex hull:" << dsv(hull) << std::endl;
line3.push_back(make<point_3d>(1,2,3));
line3.push_back(make<point_3d>(4,5,6));
line3.push_back(make<point_3d>(7,8,9));
std::cout <<
"3D: length: " <<
length(line3) <<
" line: " << dsv(line3) << std::endl;
std::cout << "JSON: "
<< dsv(ls, ", ", "[", "]", ", ", "[ ", " ]")
<< std::endl;
return 0;
}


The Lean theorem prover is a proof assistant developed principally by Leonardo de Moura at Microsoft Research.
The Lean mathematical library, mathlib, is a community-driven effort to build a unified library of mathematics formalized in the Lean proof assistant. The library also contains definitions useful for programming. This project is very active, with many regular contributors and daily activity.
The contents, design, and community organization of mathlib are described in the paper The Lean mathematical library, which appeared at CPP 2020. You can get a bird's eye view of what is in the library by reading the library overview. You can also have a look at our repository statistics to see how it grows and who contributes to it.
You can try Lean in your web browser, install it in an isolated folder, or go for the full install. Lean is free, open source software. It works on Linux, Windows, and MacOS.
You can learn by playing a game, following tutorials, or reading books.
Lean has very diverse and active community. It gathers mostly on a Zulip chat and on GitHub. You can get involved and join the fun!
A proof assistant is a piece of software that provides a language for defining objects, specifying properties of these objects, and proving that these specifications hold. The system checks that these proofs are correct down to their logical foundation.
These tools are often used to verify the correctness of programs. But they can also be used for abstract mathematics, which is something of interest to the mathlib community. In a formalization, all definitions are precisely specified and all proofs are virtually guaranteed to be correct.
In 2016, Ellenberg and Gijswijt established a new upper bound on the size of subsets of $𝔽^n_q$ with no three-term arithmetic progression. This problem has received much mathematical attention, particularly in the case $q = 3$, where it is commonly known as the cap set problem. Ellenberg and Gijswijt's proof was published in the Annals of Mathematics and is noteworthy for its clever use of elementary methods.
Perfectoid spaces are sophisticated objects in arithmetic geometry introduced by Peter Scholze in 2012. We formalised enough definitions and theorems in topology, algebra and geometry to define perfectoid spaces in the Lean theorem prover. This experiment confirms that a proof assistant can handle complexity in that direction, which is rather different from formalising a long proof about simple objects.
The continuum hypothesis states that there is no cardinality between the smallest infinite cardinal and the cardinality of the continuum. It was posed by Cantor in 1878 and was the first problem on Hilbert’s list of twenty- three unsolved problems in mathematics. Gödel and Cohen proved this is independent, i.e. neither provable nor disprovable, from ZFC.
A broad class of data types, including arbitrary nestings of inductive types, coinductive types, and quotients, can be represented as quotients of polynomial functors. This provides perspicuous ways of constructing them and reasoning about them in an interactive theorem prover.


Our Vision
The need for foodbanks in London is on the rise, with many struggling to meet basic living costs. Food is a basic human right, unfortunately today many are deprived of such essentials. We supply food and essentials items to those most in need.


sinh
, sinhf
—hyperbolic sine#include <math.h> double sinh(double x); float sinhf(float x);
Description
sinh
computes the hyperbolic sine of the argument x.
Angles are specified in radians. sinh
(x) is defined as
(exp(x) - exp(-x))/2
sinhf
is identical, save that it takes and returns float
values.
Returns
When the correct result is too large to be representable (an
overflow), sinh
returns HUGE_VAL
with the
appropriate sign, and sets the global value errno
to
ERANGE
.
Portability
sinh
is ANSI C.
sinhf
is an extension.


Select your budget to load your categories and begin setting keywords.
You can access these options any time from chrome://extensions, selecting the YNAB Website Tracker app, and viewing the "Extension options" or by right clicking the chrome extension icon in and selecting "options".


UK retail sales stabilise ahead of key Christmas trading
The CBI’s monthly survey of British retailers found sales were ‘broadly unchanged’ in November after six months of falling demand.
The downturn in the UK retail sector has significantly slowed down and shops could see sales growth return next month, according to new figures.
The CBI’s monthly survey of British retailers has found that sales were “broadly unchanged” in November, after six months of falling demand.
However, the industry was still in decline, with 41% of retailers reporting a decline in sales while 38% of respondents saw a rise, giving a balance of -3 for the month against the same period last year.
Nevertheless, this was the highest performance in seven months as the run-up to Christmas appeared to improve the situation for high street retailers.
Sales are also predicted to continue to improve, with the CBI saying it expects a return to growth in December.
Retailers said they expect sales volumes to increase for the year to December, with 44% expecting to see a rise in sales and just 23% predicting a decline.
The figures were less positive for online retailers, with online sales growing at the slowest pace since June, while wholesale sales fell at the sharpest rate in more than seven years.
Suppliers also had less to cheer about as they saw the number of new orders fall for the seventh consecutive month in annual terms.
Anna Leach, deputy chief economist at the CBI, said: “Retailers are entering the festive season with a bit of hope that sales will head up, with the strongest expectations in half a year.
“Actual sales have also stabilised and have nudged above average for the time of year and employment has stopped falling after three years of decline.
“But Brexit uncertainty continues to weigh on investment plans for the year ahead which remain weak.”


Welcome to the Slumbering Tsar Random Encounter Generator.
May Tsathogga infest with boils any Non-GMs who click below. In other words, beware spoilers!
If you like this then please also try my
Bard's Gate Rumor Mill.
Bard's Gate Rumor Mill.


UPCM - Unused Private Class Member
An unused class member might indicate a logical flaw in the program. The class declaration has to be reconsidered in order to determine the need of the unused member(s).
Wrong
private int bad_attr;
private int good_attr;
private void bad_oper () {
// do something...;
}
private void good_oper1 () {
good_attr = 10;
}
public void good_oper2() {
good_oper1();
}
}
Tip: Examine the programm. If this member is unnecessary, remove it (or at least comment it out).


Which best describes your role?
Please click Submit and wait for a confirmation.
Thank you for your participation! You submitted at TIME.
Our analysis server is not currently active. Email Vinesh Kannan<EMAIL_ADDRESS>and we will update the website with the latest anonymous results.
View All Anonymous Results1.100s


This calendar shows how to use basic-calendar-day to show custom data in a month calendar. Here, a custom subclass of basic-calendar-day has been defined to show the phase of the moon for a given date. The basic-calendar- month instance is then instructed to use that custom subclass when rendering the days in the month. In the same way, other types of date-related data could easily be shown on a calendar.


Synthesis Report #Build: Synplify Pro I-2013.09L , Build 064R, Nov 15 2013 #install: C:\lscc\diamond\3.1_x64\synpbase #OS: Windows 7 6.1 #Hostname: NICK-HP #Implementation: section6_TestFinalDesign $ Start of Compile #Thu Jun 05 23:21:46 2014 Synopsys Verilog Compiler, version comp201309rc, Build 136R, built Nov 18 2013 @N|Running in 64-bit mode Copyright (C) 1994-2013 Synopsys, Inc. This software and the associated documentation are proprietary to Synopsys, Inc. This software may only be used in accordance with the terms and conditions of a written license agreement with Synopsys, Inc. All other use or distribution of the software is strictly prohibited. @I::"C:\lscc\diamond\3.1_x64\synpbase\lib\lucent\machxo2.v" @I::"C:\lscc\diamond\3.1_x64\synpbase\lib\lucent\pmi_def.v" @I::"C:\lscc\diamond\3.1_x64\synpbase\lib\vlog\umr_capim.v" @I::"C:\lscc\diamond\3.1_x64\synpbase\lib\vlog\scemi_objects.v" @I::"C:\lscc\diamond\3.1_x64\synpbase\lib\vlog\scemi_pipes.svh" @I::"C:\lscc\diamond\3.1_x64\synpbase\lib\vlog\hypermods.v" @I::"C:\lscc\diamond\3.1_x64\bin\nt64\Lab6_Test\section6_TestFinalDesign\source\determineNum.v" @I::"C:\lscc\diamond\3.1_x64\bin\nt64\Lab6_Test\section6_TestFinalDesign\source\Section6_SM.v" @I::"C:\lscc\diamond\3.1_x64\bin\nt64\Lab6_Test\section6_TestFinalDesign\source\Section6_Top.v" @I::"C:\lscc\diamond\3.1_x64\bin\nt64\Lab6_Test\section6_TestFinalDesign\source\sevenseg.v" @I::"C:\lscc\diamond\3.1_x64\bin\nt64\Lab6_Test\section6_TestFinalDesign\source\clock_counter.v" @I::"C:\lscc\diamond\3.1_x64\bin\nt64\Lab6_Test\section6_TestFinalDesign\source\ADC_module.v" @I::"C:\lscc\diamond\3.1_x64\bin\nt64\Lab6_Test\section6_TestFinalDesign\source\interpretADC.v" Verilog syntax check successful! File C:\lscc\diamond\3.1_x64\bin\nt64\Lab6_Test\section6_TestFinalDesign\source\determineNum.v changed - recompiling Selecting top level module Sec6_Top @N: CG364 :"C:\lscc\diamond\3.1_x64\synpbase\lib\lucent\machxo2.v":1793:7:1793:10|Synthesizing module OSCH @N: CG364 :"C:\lscc\diamond\3.1_x64\bin\nt64\Lab6_Test\section6_TestFinalDesign\source\clock_counter.v":1:7:1:19|Synthesizing module clock_counter @N: CG364 :"C:\lscc\diamond\3.1_x64\bin\nt64\Lab6_Test\section6_TestFinalDesign\source\ADC_module.v":4:7:4:18|Synthesizing module ADCinterface @N: CG364 :"C:\lscc\diamond\3.1_x64\bin\nt64\Lab6_Test\section6_TestFinalDesign\source\Section6_SM.v":1:7:1:13|Synthesizing module Sec6_SM @N: CG364 :"C:\lscc\diamond\3.1_x64\bin\nt64\Lab6_Test\section6_TestFinalDesign\source\interpretADC.v":1:7:1:18|Synthesizing module interpretADC @N: CG364 :"C:\lscc\diamond\3.1_x64\bin\nt64\Lab6_Test\section6_TestFinalDesign\source\determineNum.v":1:7:1:18|Synthesizing module determineNum @N: CG364 :"C:\lscc\diamond\3.1_x64\bin\nt64\Lab6_Test\section6_TestFinalDesign\source\sevenseg.v":1:7:1:14|Synthesizing module sevenSeg @N: CG364 :"C:\lscc\diamond\3.1_x64\bin\nt64\Lab6_Test\section6_TestFinalDesign\source\Section6_Top.v":1:7:1:14|Synthesizing module Sec6_Top @N: CL201 :"C:\lscc\diamond\3.1_x64\bin\nt64\Lab6_Test\section6_TestFinalDesign\source\Section6_SM.v":21:1:21:6|Trying to extract state machine for register state Extracted state machine for register state State machine has 4 reachable states with original encodings of: 00 01 10 11 @W: CL190 :"C:\lscc\diamond\3.1_x64\bin\nt64\Lab6_Test\section6_TestFinalDesign\source\clock_counter.v":11:2:11:7|Optimizing register bit count[13] to a constant 0 @W: CL190 :"C:\lscc\diamond\3.1_x64\bin\nt64\Lab6_Test\section6_TestFinalDesign\source\clock_counter.v":11:2:11:7|Optimizing register bit count[14] to a constant 0 @W: CL279 :"C:\lscc\diamond\3.1_x64\bin\nt64\Lab6_Test\section6_TestFinalDesign\source\clock_counter.v":11:2:11:7|Pruning register bits 14 to 13 of count[14:0] @END At c_ver Exit (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 71MB peak: 72MB) Process took 0h:00m:01s realtime, 0h:00m:01s cputime # Thu Jun 05 23:21:47 2014 ###########################################################] Premap Report Synopsys Lattice Technology Pre-mapping, Version maplat, Build 800R, Built Nov 18 2013 10:58:25 Copyright (C) 1994-2013, Synopsys, Inc. This software and the associated documentation are proprietary to Synopsys, Inc. This software may only be used in accordance with the terms and conditions of a written license agreement with Synopsys, Inc. All other use or distribution of the software is strictly prohibited. Product Version I-2013.09L Mapper Startup Complete (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 99MB peak: 100MB) @L: C:\lscc\diamond\3.1_x64\bin\nt64\Lab6_Test\section6_TestFinalDesign\section6_TestFinalDesign_section6_TestFinalDesign_scck.rpt Printing clock summary report in "C:\lscc\diamond\3.1_x64\bin\nt64\Lab6_Test\section6_TestFinalDesign\section6_TestFinalDesign_section6_TestFinalDesign_scck.rpt" file @N: MF248 |Running in 64-bit mode. @N: MF666 |Clock conversion enabled Design Input Complete (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 100MB peak: 102MB) Mapper Initialization Complete (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 100MB peak: 102MB) Start loading timing files (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 114MB peak: 115MB) Finished loading timing files (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 114MB peak: 117MB) @N: MF236 :"c:\lscc\diamond\3.1_x64\bin\nt64\lab6_test\section6_testfinaldesign\source\interpretadc.v":7:15:7:35|Generating a type div divider @N: MF236 :"c:\lscc\diamond\3.1_x64\bin\nt64\lab6_test\section6_testfinaldesign\source\determinenum.v":19:37:19:49|Generating a type div divider @N: MF236 :"c:\lscc\diamond\3.1_x64\bin\nt64\lab6_test\section6_testfinaldesign\source\determinenum.v":18:36:18:47|Generating a type div divider @N: MF236 :"c:\lscc\diamond\3.1_x64\bin\nt64\lab6_test\section6_testfinaldesign\source\determinenum.v":18:20:18:33|Generating a type div divider @N: MF237 :"c:\lscc\diamond\3.1_x64\bin\nt64\lab6_test\section6_testfinaldesign\source\determinenum.v":17:20:17:32|Generating a type rem remainder syn_allowed_resources : blockrams=26 set on top level netlist Sec6_Top Clock Summary ************** Start Requested Requested Clock Clock Clock Frequency Period Type Group ------------------------------------------------------------------------------------------------------------------------------------ Sec6_Top|clk_inferred_clock 1.0 MHz 1000.000 inferred Inferred_clkgroup_0 clock_counter|clk_o_derived_clock 1.0 MHz 1000.000 derived (from Sec6_Top|clk_inferred_clock) Inferred_clkgroup_0 ==================================================================================================================================== @W: MT529 :"c:\lscc\diamond\3.1_x64\bin\nt64\lab6_test\section6_testfinaldesign\source\clock_counter.v":11:2:11:7|Found inferred clock Sec6_Top|clk_inferred_clock which controls 23 sequential elements including counter_1.count[12:0]. This clock has no specified timing constraint which may prevent conversion of gated or generated clocks and may adversely impact design performance. Pre-mapping successful! At Mapper Exit (Real Time elapsed 0h:00m:02s; CPU Time elapsed 0h:00m:02s; Memory used current: 79MB peak: 143MB) Process took 0h:00m:02s realtime, 0h:00m:02s cputime # Thu Jun 05 23:21:51 2014 ###########################################################] Map & Optimize Report Synopsys Lattice Technology Mapper, Version maplat, Build 800R, Built Nov 18 2013 10:58:25 Copyright (C) 1994-2013, Synopsys, Inc. This software and the associated documentation are proprietary to Synopsys, Inc. This software may only be used in accordance with the terms and conditions of a written license agreement with Synopsys, Inc. All other use or distribution of the software is strictly prohibited. Product Version I-2013.09L Mapper Startup Complete (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 99MB peak: 99MB) @N: MF248 |Running in 64-bit mode. @N: MF666 |Clock conversion enabled Design Input Complete (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 99MB peak: 100MB) Mapper Initialization Complete (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 99MB peak: 100MB) Start loading timing files (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 114MB peak: 115MB) Finished loading timing files (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 114MB peak: 117MB) Starting Optimization and Mapping (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 140MB peak: 143MB) Available hyper_sources - for debug and ip models None Found @N: FA239 :"c:\lscc\diamond\3.1_x64\bin\nt64\lab6_test\section6_testfinaldesign\source\sevenseg.v":6:2:6:5|ROM segDecoder.segments_1[6:0] mapped in logic. @N: FA239 :"c:\lscc\diamond\3.1_x64\bin\nt64\lab6_test\section6_testfinaldesign\source\sevenseg.v":6:2:6:5|ROM segDecoder.segments_1[6:0] mapped in logic. @N: MO106 :"c:\lscc\diamond\3.1_x64\bin\nt64\lab6_test\section6_testfinaldesign\source\sevenseg.v":6:2:6:5|Found ROM, 'segDecoder.segments_1[6:0]', 16 words by 7 bits Finished RTL optimizations (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 143MB peak: 143MB) Encoding state machine state[3:0] (view:work.Sec6_SM(verilog)) original code -> new code 00 -> 00 01 -> 01 10 -> 10 11 -> 11 Finished factoring (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 143MB peak: 143MB) Finished gated-clock and generated-clock conversion (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 143MB peak: 144MB) Finished generic timing optimizations - Pass 1 (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 144MB peak: 144MB) Starting Early Timing Optimization (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 144MB peak: 145MB) Finished Early Timing Optimization (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 144MB peak: 145MB) Finished generic timing optimizations - Pass 2 (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 144MB peak: 145MB) Finished preparing to map (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 144MB peak: 145MB) Finished technology mapping (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 145MB peak: 146MB) Pass CPU time Worst Slack Luts / Registers ------------------------------------------------------------ Pass CPU time Worst Slack Luts / Registers ------------------------------------------------------------ ------------------------------------------------------------ Finished technology timing optimizations and critical path resynthesis (Real Time elapsed 0h:00m:00s; CPU Time elapsed 0h:00m:00s; Memory used current: 145MB peak: 146MB) @N: FX164 |The option to pack flops in the IOB has not been specified Finished restoring hierarchy (Real Time elapsed 0h:00m:01s; CPU Time elapsed 0h:00m:01s; Memory used current: 145MB peak: 146MB) #### START OF CLOCK OPTIMIZATION REPORT #####[ 0 non-gated/non-generated clock tree(s) driving 0 clock pin(s) of sequential element(s) 1 gated/generated clock tree(s) driving 25 clock pin(s) of sequential element(s) 0 instances converted, 25 sequential instances remain driven by gated/generated clocks ================================================================================================= Gated/Generated Clocks ================================================================================================= Clock Tree ID Driving Element Drive Element Type Fanout Sample Instance Explanation -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- @K:CKID0001 osc_int OSCH 25 FSM_1.state[1] Gating structure creates improper gating logic. See the Gated Clocks description in the user guide for conversion requirements ========================================================================================================================================================================================================================== ##### END OF CLOCK OPTIMIZATION REPORT ######] Writing Analyst data base C:\lscc\diamond\3.1_x64\bin\nt64\Lab6_Test\section6_TestFinalDesign\section6_TestFinalDesign_section6_TestFinalDesign.srm Finished Writing Netlist Databases (Real Time elapsed 0h:00m:01s; CPU Time elapsed 0h:00m:01s; Memory used current: 143MB peak: 146MB) Writing EDIF Netlist and constraint files @W: MT558 |Unable to locate source for clock clock_counter|clk_o_derived_clock. Clock will not be forward annotated I-2013.09L @N: BW106 |Synplicity Constraint File capacitance units using default value of 1pF Finished Writing EDIF Netlist and constraint files (Real Time elapsed 0h:00m:01s; CPU Time elapsed 0h:00m:01s; Memory used current: 147MB peak: 149MB) @W: MT246 :"c:\lscc\diamond\3.1_x64\bin\nt64\lab6_test\section6_testfinaldesign\source\section6_top.v":19:16:19:22|Blackbox OSCH is missing a user supplied timing model. This may have a negative effect on timing analysis and optimizations (Quality of Results) @W: MT420 |Found inferred clock Sec6_Top|clk_inferred_clock with period 1000.00ns. Please declare a user-defined clock on object "n:clk" ##### START OF TIMING REPORT #####[ # Timing Report written on Thu Jun 05 23:21:53 2014 # Top view: Sec6_Top Requested Frequency: 1.0 MHz Wire load mode: top Paths requested: 5 Constraint File(s): @N: MT320 |Timing report estimates place and route data. Please look at the place and route timing report for final timing. @N: MT322 |Clock constraints cover only FF-to-FF paths associated with the clock. Performance Summary ******************* Worst slack in design: 994.561 Requested Estimated Requested Estimated Clock Clock Starting Clock Frequency Frequency Period Period Slack Type Group ------------------------------------------------------------------------------------------------------------------------------------ Sec6_Top|clk_inferred_clock 1.0 MHz 183.9 MHz 1000.000 5.439 994.561 inferred Inferred_clkgroup_0 ==================================================================================================================================== Clock Relationships ******************* Clocks | rise to rise | fall to fall | rise to fall | fall to rise -------------------------------------------------------------------------------------------------------------------------------------------------- Starting Ending | constraint slack | constraint slack | constraint slack | constraint slack -------------------------------------------------------------------------------------------------------------------------------------------------- Sec6_Top|clk_inferred_clock Sec6_Top|clk_inferred_clock | 1000.000 994.561 | No paths - | No paths - | No paths - ================================================================================================================================================== Note: 'No paths' indicates there are no paths in the design for that pair of clock edges. 'Diff grp' indicates that paths exist but the starting clock and ending clock are in different clock groups. Interface Information ********************* No IO constraint found ==================================== Detailed Report for Clock: Sec6_Top|clk_inferred_clock ==================================== Starting Points with Worst Slack ******************************** Starting Arrival Instance Reference Type Pin Net Time Slack Clock ----------------------------------------------------------------------------------------------------------- counter_1.count[3] Sec6_Top|clk_inferred_clock FD1S3DX Q count[3] 1.044 994.561 counter_1.count[4] Sec6_Top|clk_inferred_clock FD1S3DX Q count[4] 1.044 994.561 counter_1.count[5] Sec6_Top|clk_inferred_clock FD1S3DX Q count[5] 1.044 994.561 counter_1.count[6] Sec6_Top|clk_inferred_clock FD1S3DX Q count[6] 1.044 994.561 counter_1.count[0] Sec6_Top|clk_inferred_clock FD1S3DX Q count[0] 1.044 994.621 counter_1.count[1] Sec6_Top|clk_inferred_clock FD1S3DX Q count[1] 0.972 994.836 counter_1.count[2] Sec6_Top|clk_inferred_clock FD1S3DX Q count[2] 0.972 994.836 int.count[0] Sec6_Top|clk_inferred_clock FD1S3DX Q count[0] 1.108 994.842 int.count[1] Sec6_Top|clk_inferred_clock FD1S3DX Q count[1] 1.108 994.985 int.count[2] Sec6_Top|clk_inferred_clock FD1S3DX Q count[2] 1.108 994.985 =========================================================================================================== Ending Points with Worst Slack ****************************** Starting Required Instance Reference Type Pin Net Time Slack Clock ----------------------------------------------------------------------------------------------------------------- FSM_1.state[1] Sec6_Top|clk_inferred_clock FD1P3DX SP state_RNO[1] 999.528 994.561 counter_1.count[12] Sec6_Top|clk_inferred_clock FD1S3DX D count_3[12] 1000.089 994.621 counter_1.count[9] Sec6_Top|clk_inferred_clock FD1S3DX D count_3[9] 1000.089 994.764 int.count[7] Sec6_Top|clk_inferred_clock FD1S3DX D count_3[7] 1000.089 994.842 counter_1.count[7] Sec6_Top|clk_inferred_clock FD1S3DX D count_3[7] 1000.089 994.906 counter_1.count[8] Sec6_Top|clk_inferred_clock FD1S3DX D count_3[8] 1000.089 994.906 int.count[6] Sec6_Top|clk_inferred_clock FD1S3DX D count_3[6] 1000.089 994.985 counter_1.count[11] Sec6_Top|clk_inferred_clock FD1S3DX D count_2[11] 999.894 995.043 counter_1.clk_o Sec6_Top|clk_inferred_clock FD1S3DX D clk_o_mx 1000.089 995.122 counter_1.count[0] Sec6_Top|clk_inferred_clock FD1S3DX D count_3[0] 1000.089 995.122 ================================================================================================================= Worst Path Information *********************** Path information for path number 1: Requested Period: 1000.000 - Setup time: 0.472 + Clock delay at ending point: 0.000 (ideal) = Required time: 999.528 - Propagation time: 4.967 - Clock delay at starting point: 0.000 (ideal) = Slack (critical) : 994.561 Number of logic level(s): 4 Starting point: counter_1.count[3] / Q Ending point: FSM_1.state[1] / SP The start point is clocked by Sec6_Top|clk_inferred_clock [rising] on pin CK The end point is clocked by Sec6_Top|clk_inferred_clock [rising] on pin CK Instance / Net Pin Pin Arrival No. of Name Type Name Dir Delay Time Fan Out(s) ------------------------------------------------------------------------------------------- counter_1.count[3] FD1S3DX Q Out 1.044 1.044 - count[3] Net - - - - 2 counter_1.un1_countlto6 ORCALUT4 A In 0.000 1.044 - counter_1.un1_countlto6 ORCALUT4 Z Out 1.017 2.061 - un1_countlt9 Net - - - - 1 counter_1.un1_countlto9 ORCALUT4 D In 0.000 2.061 - counter_1.un1_countlto9 ORCALUT4 Z Out 1.017 3.077 - un1_countlt11 Net - - - - 1 counter_1.un1_countlto12 ORCALUT4 D In 0.000 3.077 - counter_1.un1_countlto12 ORCALUT4 Z Out 1.273 4.350 - un1_count Net - - - - 9 FSM_1.state_RNO[1] ORCALUT4 B In 0.000 4.350 - FSM_1.state_RNO[1] ORCALUT4 Z Out 0.617 4.967 - state_RNO[1] Net - - - - 1 FSM_1.state[1] FD1P3DX SP In 0.000 4.967 - =========================================================================================== ##### END OF TIMING REPORT #####] --------------------------------------- Resource Usage Report Part: lcmxo2_7000he-4 Register bits: 25 of 6864 (0%) PIC Latch: 0 I/O cells: 23 Details: CCU2D: 128 FD1P3DX: 1 FD1S3DX: 24 GSR: 1 IB: 9 INV: 17 OB: 14 ORCALUT4: 59 OSCH: 1 PFUMX: 2 PUR: 1 VHI: 6 VLO: 6 false: 1 true: 1 Mapper successful! At Mapper Exit (Real Time elapsed 0h:00m:01s; CPU Time elapsed 0h:00m:01s; Memory used current: 53MB peak: 149MB) Process took 0h:00m:01s realtime, 0h:00m:01s cputime # Thu Jun 05 23:21:53 2014 ###########################################################]


These are projects my friend and I have started working on. Some are completed or have blueprints; others aren't. I have listed them in order of when I am gonig to do them.
| Ideas | Start Date | Cost | End Date |
|---|---|---|---|
| Ball | # | $0.00 | # |
| Quad | # | $0.00 | # |
| Bug | # | $0.00 | # |
| Spider | # | $0.00 | # |
| Copter | # | $0.00 | # |
| Updated 3/12 |


{% blocktrans %} A lot of folks find it hard to make their place on the internet, either due to busy schedules or lack of knowledge. This is exactly where we fit in. Our team has spent their careers on everything from a simple one page product displays to full blown order management systems. {% endblocktrans %}
{% blocktrans %} We provide you not only the end product you ask for, but the knowledge and guidance needed to continue your creation to be beautiful, easy to maintain, and simple for your users. It very simple, we believe in what you are doing and we want to make sure as your partner, we give you the best experience. {% endblocktrans %}
{% blocktrans %} Zak has over 6 years providing top notch internet experiences. He really loves this stuff. {% endblocktrans %}
{% blocktrans %} Judy has spent over 6 years finding diamonds in the data ruff. She enjoys the hunt for metrics. {% endblocktrans %}
{% blocktrans %} Created in August 2012, Brainfire LLC has strived on providing simple yet amazing web experiences that help companies succeed on the internet. We have lived in the web since it's creation (and a little before, but don't tell anyone) and have watched it turn from a small group of information sharing to a massive world of it's own. {% endblocktrans %}


TensorFlow.js Layers: Sentiment Analysis Demo
Load hosted pretrained model
Load local pretrained model
Model type:
Vocabulary size:
Max length:
Positive example
Negative example
Standing by.


Most of the details about data tables have been covered in Content/Tables documentation. Please refer to this page for more details.
Tables within cards
Tables may be embedded within a card.
| # |
First Name |
Last Name |
Username |
| 1 |
Mark |
Otto |
@mdo |
| 2 |
Jacob |
Thornton |
@fat |
| 3 |
Larry |
the Bird |
@twitter |
Data manipulation tools and table navigation can be added using card components.
| # |
First Name |
Last Name |
Username |
| 1 |
Mark |
Otto |
@mdo |
| 2 |
Jacob |
Thornton |
@fat |
| 3 |
Larry |
the Bird |
@twitter |
Rows per page:
1-3 of 300
chevron_left
chevron_right