Issue Two
Underneath Annabelle's somber eyes and ghostly skin, she was lovely. Her small smiles were infectious in a way that went unnoticed; she was a good kid, the best half-sister anyone could have.
“Why is life so awful,” she moaned, letting her head fall backwards.
“Because Clue isn’t much fun with two players,” I told her. She sat across from me, leaning over with her hands gripping the edge of her seat. As she stared at the board with her distant gray eyes, it was hard to believe she was turning thirteen in a couple month.
“Clue isn’t fun. Period,” she pouted. I laughed; she did too.
Vietnam traveled through the radios and televisions and clung to the American air. Still, no one could completely fathom the chaos five-thousand miles away, let alone in our backyards. We were unaware.
The doorknob suddenly jiggled. Daw was home.
Fiddling with a pocket knife, he stepped into the kitchen, a restlessness dispersing into the air with every footstep. Our muscles tensed.
“Hey, kiddos,” he said grandly, before directing his attention to Annabelle. She was Daw’s first and only child, and her youth was enticing. He nudged his head towards the back door. “Let’s go for a walk.” I think it scared the hell out of her.
Annabelle smiled. Her eyes continued to look down at the board.
“We’re playing Clue—,” she started. Daw grinned. His yellow-teeth were disgusting.
“I really think we should go for a walk.”
They shouldn’t. Walks were always bad.
I glanced at Annabelle uneasily, but then pulled back when I saw her playing with the black beaded necklace Daw had gifted her last Valentine’s Day.
I looked away.
Flicking the plastic figurine of a revolver across the board, I said, “Guess we’re done then.”  Daw lent out a hand, and she took it. Side by side, they silently shuffled outside.
As I put away the board game, I noticed the faint war reports of the radio on the kitchen window-sill. I glanced past the radio and saw Annabelle walking down the street in her oversized nightgown and off-white ballerina slippers with her right hand intertwined with Daw’s. I wondered if the neighbors ever noticed or if it had become all too ordinary.
The coming months of Vietnam would sweep us off our feet.
During the time Daw lived with our family, he carried a small, camouflage pouch by his hip. He kept his pocket-knives inside of it. I would awake to Daw restlessly marching around the house with one of the knives. The radio would blast monotonous newscasters voices, reporting the war with the rise of the morning sun.
“I’m gonna show ‘em a real fighter,” he would smirk, tapping me violently against the chest, when I walked into the kitchen. As a new enlistee for the war, Daw’s spirit seemed unbreakable compared to the rest of the country. “Something that comes from inside, and I have it,” he would continue, with a mischievous glimmer. His eyes would dart around the room until they were looking straight into mine. “You have it, too.” Boy, I didn’t want to have it.
Yet, I never could summon the courage to shake my head. If I did, he would playfully drag the switchblade under my chin. “You have it,” he would repeat as if he were trying to turn an eighteen year-old boy into a man with the tickle of a knife. I always swallowed my defiance and pressed it deep into the pit of my stomach.
(continued in-print in Issue Two of Postscript)
Ian Sherman is co-editor-in-chief of the Trevor Day School’s literary magazine, founder of the Psychology Club, and column editor of the newspaper. He has been recognized on national and regional levels by Scholastic Art & Writing Awards for over 5 years in genres from humor and dramatic scripts to short stories. In 2012, Ian had his one-act play “Standing Voiceless in the Choir” produced Off-Broadway at 59E59 Theaters in NYC as a part of Writopia Lab’s Playwright Festival, also put on as a dramatic reading by the TACT (The Actors Company Theatre) in New York. Most recently, two of his poems were featured in Teen Art Gallery’s 2013 July exhibition at Chashama. Overall, Ian hopes to impact others with insightful and heart-warming works.
Copyright © 2012-2015, The Postscript Journal. All rights reserved.


"Keep the River On Your Right - A Modern Cannibal Tale"
Artist, anthropologist, archaeologist and writer Tobias Schneebaum has led, to say the very least, a colorful life. 45 years ago and funded by a Fulbright grant, this renaissance man walked into the jungles of Peru in a pair of canvas sneakers and the clothes on his back and spent a year living with a cannibal tribe. But there is a lot more to tell about the man in documentary filmmakers David Shapiro and Laurie Gwen Shapiro's thought provoking work, "Keep the River On Your Right - A Modern Cannibal Tale."
I knew nothing, a few days ago, about Tobias Schneebaum, his fascinating life and studies about primitive cultures. "Keep the River?" opened my eyes to the story of this incredible man who, at age 78, is brought back to those places he explored, alone, so many years ago. We learn, early on, that Tobias was, at one time, an accomplished painter who gave up his art to study anthropology. Taking his new knowledge and the Fulbright money he cast aside the trappings of civilization to enter the primitive, cannibal culture of the Harakambuit tribe of the Amazon.
This journey, though, is not all that "Keep the River?" is about. Tobias made a similar trip, some years later, into the jungles of New Guinea to live with another cannibal tribe, the Asmat. He is taken, by the Shapiros, on a new trek that will bring him back to his past lives in those distant places. At first, the septuagenarian is reluctant to make the arduous trip. He's afraid that his frailty may betray him and the possibility of breaking a hip, again, is genuine. More telling, though, is his fear of facing his past. It has been so long since he ventured to those distant places, he is sure that nothing and no one from that past is even left.
One of the many joys of "Keep the River On Your Right" is to see Tobias's reluctance to take the journey replaced with a real satisfaction and happiness for having made the enormous effort. Almost miraculously, in both Peru and Borneo, he meets old friends from his time in the jungle decades before. Most striking is his reunion with Aipat, an Asmat tribesman who was Tobias's best friend and lover those many years ago. The wash of emotions that Tobias feels are palpably depicted and both gladness and sadness come through. Another poignant moment happens when Schneebaum returns to Peru and meets, again, a tribesman who remembers him from 45 years ago. It's an amazing story all around.
The Shapiros have crafted a docu work that utilizes modern footage (shot terrifically by Jonathan Kobel), archival file film recordings, excerpts from Tobia's files, clips from the feature film "Trader Horn" and the anthropologist's interview on The Mike Douglas Show from 1969. The Douglas show, in particular, is most revealing as Tobias tells the emcee and his guests that he did, in fact, eat human flesh when living in Peru. The reaction, universally, is one of revulsion by the host and his panel, with the almost instantaneous follow-up question, "what did it taste like?" showing our morbid curiosity about such things. ("It tastes like pork" according to Tobias.)
The unbridled honesty of Tobias's telling of his story - he pulls no punches when he talks about his homosexuality or of eating another person - is an unexpected treat. He shares his years of experience with us as he talks about life and its wonders, of death and aging, and about living life to its fullest. You can't help but come out of the theater feeling the positive vibes of this fascinating little man.
There have been some first rate documentary films making it to theaters in recent years. "One Day in September" is a gripping document about the Jewish hostages taken by Arab terrorists during the 1972 Munich Olympics. "Sound and Fury" chronicles the real controversy of curing deafness in children. "Keep the River On Your Right - A Modern Cannibal Tale" brings us into the life and times of Tobias Schneebaum, a truly remarkable man. Even is you don't like documentary films, this is one worth seeing. I give it an A.
For more Reeling reviews visit www.reelingreviews.com
<EMAIL_ADDRESS><EMAIL_ADDRESS>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


Main Concepts
About Templates - Property Binding - the basics
-
In the previous sample, we wrote:
sub-cmp name="john"
-
And, John was directly evaluated as
a string
-
The attribute is not considered as an Angular
expression by default
-
In HTML5, values set to attributes
are interpreted as strings and
Angular respects this norm
-
So the following "naïve" approach to set a
complex object to a child component will
not give the result we expect!
import {Component} from '@angular/core';
import {BrowserModule} from '@angular/platform-browser';
import {SubCmp} from './sub-cmp';
@Component({
selector: 'app',
template: ''
})
class App {
name: string= 'john';
friends: string[]= ['bob', 'dylan'];
}
export const ModuleDefs= {
bootstrap: [App],
declarations:[ App, SubCmp],
imports: [BrowserModule]
}
import {Component, Input} from '@angular/core';
@Component({
selector: 'sub-cmp',
template: `

Name: {{name}}

Friends:

{{friend}}

`
})
export class SubCmp {
@Input() name: string;
@Input() friends: string[];
}
-
What happened here?
Which value is really passed to SubCmp.friends ?
-
What could you do to force to pass your value?


Home
Activities
Gallery
Reservations
Getting Here
Contact Us
We do not take any reservations except those provided in rhyming couplets. Please make your reservation.


Hello!
This is DC-Modal demo. try it out
Enjoy coding!
Build with Yeoman
Open default dialog
Open two dialogs
Open dialog with controller (object)
Open dialog with controller (function)


Just Building some stuff from TAILWIND
(and playing arround :)
"Building This Stuff"
"Building This Stuff"
"Building This Stuff"
"Building This Stuff"
"Building This Stuff"
"Building This Stuff"
"Building This Stuff"
"Building This Stuff"


Made With 💙 by Deven
Home
Request movie
Contact
About
Upload Movies
Welcome To Free Movie Server
click on Show Button to see all movies
Show
Evil Dead 2013
Annabelle Creation (2017)
Insidious The Last Key (2018)
The Conjuring 2 2016
Dawn of Justice
Suicide Squad
John Wick Chapter 1
John Wick Chapter 2
John Wick Chapter 3
Lost In Space S1
Lost In Space S2
Pacific Rim 2013
Pacific Rim Uprising 2017


--- layout: page title: Pricing ---
Projects you've backed
Following
Someone you follow has backed or launched a project
Someone has followed you
Campus
A new answer has been posted on a question you follow
A daily digest of any follows or upvotes on your posts
Projects you've launched
New pledge activity (backings, adjustments, cancellations)
New comments
New likes
Tips for creators
Advice and guidance to help you run your project


the aesthetics exist from a software development point of view. that beauty has a reason to be considered in programming. he doesn’t dive in technicalities, though, rather on how programmers experience programming, and does so through the lens of aesthetics. my contribution would be to add this technicality, and broaden it to other groups.
interesting pages are: pp.159-201 - pp.201-237
the assumption is that programming is about personal expression and belonging (programming as a religious practice)
a deeper aspect is “the fertility of fantasy and its role in the processes of technological innovation”, or “the impossibility of curbing the abundance of life” (feyerabend)
our current understanding of software engineering is one of efficiency (and there are other values at play in other types of programming, artistic, academic, hacking).
he argues that the complexity of programming is not so much an absolute one (“oh, it belongs to computation”), but also a personal one, brought it by programmers themselves.
the program being written “how it should be done” is reminiscent of Pye’s aesthetics of worksmanship and moral commitment to quality.
the inherent properties of software:
Paul W. Oman’s and Curtis R. Cook’s paper Typographic Style is More than Cosmetic (Oman and Cook 1990) argue for typographic importance in source code.
In programming, as in the majority of disciplines of human activity, there are different, sometimes opposed, notions of what it is that makes something beautiful. A complete classification of all these ideals for the case of programming coding styles would be a nice thing to present, but I cannot do that. The main problem is not that there are so many programmers scattered all over the world, not even that they lack a formal organising body; the real problem is that beauty, in programming, is a private affair, something kept among pro- grammers and absent from the official discourse: pro- grammers are not supposed to spend their time creating beauty, they are supposed to create programs that work. p.117
section on readability as choice, and highlights:
the concept of vanity in programmers.
most popular aesthetic attributes of software (all non-aesthetic terms used in an aesthetic sense)
kant says that beauty is separate from both theory and practice. i agree.
however, he says that one possesses all the necessary knowledge to appreciate something as beautiful or not. I would argue that there are different levels of knowledge which imply different levels of beauty in the same object. so it’s about the subjectivity of beauty*. not sure if I agree with this either, since there could be some structural, beautiful forms (by the way, are patterns beautiful, from alexander’s perspective?).
are there canons of beauty in programming? probably, to a certain extent, but they are highly context-dependent.
elegance is irreducible but correlated with manifestations.
metaphor of the colorful painting: colorful is not inherently beautiful or not, but when applied to something beautiful, it is correlated by the manifestation of a lot of colors, say in particularly rich or vivid palettes.
apparently, sibley says that is impossible to define what is “beautifully combined”. well if you take a goal-oriented approach, it becomes actually easy: does it do the job? (not completely explanatory but partially). because, yes, we don’t use rules, but we use heuristics.
coming back to the “what it does”, there can be a parallel seen between the aesthetic aspect of software and its public aspect? re-use -> zusammenleben -> habitability
private aesthetics vs. public aesthetics?
analyses:
types of goodness:
he also assumes that code is a sort of self-expression. i’m not so sure.
is instrumental goodness computer beauty, and intrinsic goodness human beauty?
unquantifiable does not mean un-manifested!
aesthetic discussions in slashdot seem to be related to moral statements


|
keigeki
1.0.0
傾撃
|
Go to the source code of this file.
Macros | |
| #define | CC_ENABLE_GL_STATE_CACHE 0 |
| #define | CC_FIX_ARTIFACTS_BY_STRECHING_TEXEL 0 |
| #define | CC_DIRECTOR_STATS_INTERVAL (0.1f) |
| #define | CC_DIRECTOR_STATS_POSITION ccp(0,0) |
| #define | CC_DIRECTOR_IOS_USE_BACKGROUND_THREAD 0 |
| #define | CC_MAC_USE_DISPLAY_LINK_THREAD 0 |
| #define | CC_MAC_USE_OWN_THREAD 1 |
| #define | CC_MAC_USE_MAIN_THREAD 2 |
| #define | CC_DIRECTOR_MAC_THREAD CC_MAC_USE_DISPLAY_LINK_THREAD |
| #define | CC_NODE_RENDER_SUBPIXEL 1 |
| #define | CC_SPRITEBATCHNODE_RENDER_SUBPIXEL 1 |
| #define | CC_TEXTURE_ATLAS_USE_TRIANGLE_STRIP 0 |
| #define | CC_TEXTURE_ATLAS_USE_VAO 1 |
| #define | CC_USE_LA88_LABELS 1 |
| #define | CC_SPRITE_DEBUG_DRAW 0 |
| #define | CC_LABELBMFONT_DEBUG_DRAW 0 |
| #define | CC_LABELATLAS_DEBUG_DRAW 0 |
| #define | CC_ENABLE_PROFILERS 0 |
cocos2d (cc) configuration file
| #define CC_DIRECTOR_IOS_USE_BACKGROUND_THREAD 0 |
If enabled, cocos2d-ios will run on a background thread. If disabled cocos2d-ios will run the main thread.
To enable set it to a 1, to disable it set to 0. Enabled by default.
Only valid for cocos2d-ios. Not supported on cocos2d-mac.
This is an EXPERIMENTAL feature. Do not use it unless you are a developer.
| #define CC_DIRECTOR_MAC_THREAD CC_MAC_USE_DISPLAY_LINK_THREAD |
cocos2d-mac can run on its own thread, on the Display Link thread, or in the main thread. If you are developing a game, the Display Link or Own thread are the best alternatives. If you are developing an editor that uses AppKit, you might need to use the Main Thread (only if you are lazy and don't want to create a sync queue).
Options: CC_MAC_USE_DISPLAY_LINK_THREAD (default) CC_MAC_USE_OWN_THREAD CC_MAC_USE_MAIN_THREAD
Only valid for cocos2d-mac. Not supported on cocos2d-ios.
| #define CC_DIRECTOR_STATS_INTERVAL (0.1f) |
Seconds between stats updates. 0.5 seconds, means that the stats will be updated every 0.5 seconds. Having a bigger number means more stable stats
Default value: 0.1f
| #define CC_DIRECTOR_STATS_POSITION ccp(0,0) |
Position of the FPS
Default: 0,0 (bottom-left corner)
| #define CC_ENABLE_GL_STATE_CACHE 0 |
If enabled, cocos2d will maintain an OpenGL state cache internally to avoid unnecessary switches. In order to use them, you have to use the following functions, insead of the the GL ones:
If this functionality is disabled, then ccGLUseProgram(), ccGLDeleteProgram(), ccGLBlendFunc() will call the GL ones, without using the cache.
It is recommened to enable it whenever possible to improve speed. If you are migrating your code from GL ES 1.1, then keep it disabled. Once all your code works as expected, turn it on.
Default value: Disabled by default
| #define CC_ENABLE_PROFILERS 0 |
If enabled, it will activate various profilers within cocos2d. This statistical data will be saved in the CCProfiler singleton. In order to display saved data, you have to call the CC_PROFILER_DISPLAY_TIMERS() macro. Useful for profiling purposes only. If unsure, leave it disabled.
To enable set it to a value different than 0. Disabled by default.
| #define CC_FIX_ARTIFACTS_BY_STRECHING_TEXEL 0 |
If enabled, the texture coordinates will be calculated by using this formula:
The same for bottom and top.
This formula prevents artifacts by using 99% of the texture. The "correct" way to prevent artifacts is by using the spritesheet-artifact-fixer.py or a similar tool.
Affected nodes:
To enabled set it to 1. Disabled by default.
| #define CC_LABELATLAS_DEBUG_DRAW 0 |
If enabled, all subclasses of CCLabeltAtlas will draw a bounding box Useful for debugging purposes only. It is recommened to leave it disabled.
To enable set it to a value different than 0. Disabled by default.
| #define CC_LABELBMFONT_DEBUG_DRAW 0 |
If enabled, all subclasses of CCLabelBMFont will draw a bounding box Useful for debugging purposes only. It is recommened to leave it disabled.
To enable set it to a value different than 0. Disabled by default.
| #define CC_NODE_RENDER_SUBPIXEL 1 |
| #define CC_SPRITE_DEBUG_DRAW 0 |
If enabled, all subclasses of CCSprite will draw a bounding box. Useful for debugging purposes only. It is recommened to leave it disabled.
If the CCSprite is being drawn by a CCSpriteBatchNode, the bounding box might be a bit different. To enable set it to a value different than 0. Disabled by default: 0 – disabled 1 – draw bounding box 2 – draw texture box
| #define CC_SPRITEBATCHNODE_RENDER_SUBPIXEL 1 |
If enabled, the CCSprite objects rendered with CCSpriteBatchNode will be able to render in subpixels. If disabled, integer pixels will be used.
To enable set it to 1. Enabled by default.
| #define CC_TEXTURE_ATLAS_USE_TRIANGLE_STRIP 0 |
Use GL_TRIANGLE_STRIP instead of GL_TRIANGLES when rendering the texture atlas. It seems it is the recommend way, but it is much slower, so, enable it at your own risk
To enable set it to a value different than 0. Disabled by default.
| #define CC_TEXTURE_ATLAS_USE_VAO 1 |
By default, CCTextureAtlas (used by many cocos2d classes) will use VAO (Vertex Array Objects). Apple recommends its usage but they might consume a lot of memory, specially if you use many of them. So for certain cases, where you might need hundreds of VAO objects, it might be a good idea to disable it.
To disable it set it to 0. Enabled by default.
| #define CC_USE_LA88_LABELS 1 |
If enabled, it will use LA88 (Luminance Alpha 16-bit textures) for CCLabelTTF objects. If it is disabled, it will use A8 (Alpha 8-bit textures). LA88 textures are 6% faster than A8 textures, but they will consume 2x memory.
This feature is enabled by default.


10.20.2018
People say, "When you know, you know!" We definitely know! We are so excited to begin this next chapter in our lives and we can't wait to share our happiness with all of you!
on Oct 20, 2018 — Racine, Wisconsin
Freshman year of high school, history class. Kurt thought Calyn's name was Gallon...we're off to a good start.
After Kurt learned Calyn's name, they grew to eventually become best friends. Calyn was adamant that their relationship was platonic, but things began to change once she saw how cute Kurt was dressed for the homecoming dance!
After a lengthy period of inner turmoil, Calyn finally conceded.
"I guess we are dating." -Calyn
Again, off to a great start!
After a five year long distance relationship, during which Calyn and Kurt worked on their college degrees, Kurt joined Calyn in Florida! Together at last!!
Freed from the perils of winter, Kurt and Calyn enjoy frequent trips to the beach and wearing shorts year round.
On the most magical of days, Kurt and Calyn ventured to Hogwarts (also known as Orlando, FL). While taking pictures in front of the castle, Kurt surprised Calyn with the proposal. Unlike our previous relationship status change, this was an immediate YES!!
Fountain Banquet Hall
8505 Durand Avenue
Sturtevant, WI 53177
Comfort Inn and Suites
1154 Prairie Drive
Racine, WI 53406
262-886-6055
Hotel block rate $70/night, ask for Maske-Haffner wedding.


200 Questions
☺ Use this question generator to get to know a new friend! ☺
Click Here for Another Question!


Simple table styling.
You can find the code for the examples in /demo.
| First Name | Last Name | Super Hero |
|---|---|---|
| Peter | Parker | Spiderman |
| Bruce | Wayne | Batman |
| Clark | Kent | Superman |
| First Name | Last Name | Super Hero |
|---|---|---|
| Peter | Parker | Spiderman |
| Bruce | Wayne | Batman |
| Clark | Kent | Superman |
| First Name | Last Name | Super Hero |
|---|---|---|
| Peter | Parker | Spiderman |
| Bruce | Wayne | Batman |
| Clark | Kent | Superman |
These tables above are using presentational css .classes in the markup
Here is the scss to produce the same result with no .classes in your markup


{% extends "base.html" %} {% from "macros.html" import exercise_icon with context %} {% from "macros.html" import goal_progress_bar with context %} {% block content %}
{{ goal.title }}
Set goal


Not found
Reset Password
Key found! Please reset your password.
Sorry, your passwords do not match.
Password
Password Error
8-30 characters, numbers and symbols.
1 Number (0-9)
1 Lowercase Letter (a-z)
1 Uppercase Letter (A-Z)
1 Symbol (!@#$%^&*()_+)
Confirm Password
Password Error
© 2016 Footer


reusable-scroll-to
Scroll to #second_page
Scroll to #third_page
Element on top of the section
Element on top of the section


Menu
CoverGirl
L'Oreal
Maybelline
Revlon
Sally Henson
Miscellaneous
Brand Name Ethnic Cosmetics
Cosmetic and Travel Bags
Jane Cosmetics
>
Einstein Lip Therapy
Essence of Beauty Pads
Essie Sleek Sticks Nail Stickers
Hedy's Beeswax Assorted Lip Balm
Kiss Nail Dress
L.A. Colors Eyeshadow Palette
Nailene SensatioNail Color Gel Polish
Neutrogena Nourishing Eyeliner, Plum
New York Color Cosmetics
Nuance by Salma Hayek Lash Serum
Prestige Assorted Cosmetics
Pretty Woman Magnetix Nail Polish
Rimmel Clean Finish Foundation
Wet n Wild Cosmetics - Assorted
Wet n Wild Fergie Fringe Faux Eyelashes
Wholesale Assorted Brand Name Cosmetics
Wholesale Assorted Discount Cosmetics


Image, pattern and collage. Each image frames a natural landscape, and each composition layers lines of sky and earth of two different places in time. All photographs are taken on a Pentak K1000


repo-rss
Section: (1)Updated: 2005
Index Return to Main Contents
NAME
repo-rssSYNOPSIS
repo-rss [options] repoid1 [repoid2...]DESCRIPTION
repo-rss is a program for generating RSS feeds for one or more Yum repositories.
GENERAL OPTIONS
- -h, --help
- Help; display a help message and then quit.
- -f <file>
- Specify the file to which the RSS will be written. Default is repo-rss.xml.
- -l <link>
- Specify the URL to the RSS feed. Default is http://yum.baseurl.org/.
- -t <title>
- Specify the title for the RSS feed. Default is "RSS Repository - Recent Packages".
- -d <description>
- Specify the description of the RSS feed. Default is "Most recent packages in Repositories".
- -r <days>
- Specify the number of days to consider most recent. Default is 3.
- --tempcache
-
Enable the use of a temporary directory for the yum cache. This is enabled by
default for non-root users.
EXAMPLES
- Generate an RSS for the updates-released repository and save it as updates-release.xml:
- repo-rss -f updates-released.xml updates-released
FILES
As repo-rss uses YUM libraries for retrieving all the information, it relies on YUM configuration for its default values like which repositories to use. Consult YUM documentation for details:
/etc/yum.conf /etc/yum/repos.d/ /var/cache/yum/
SEE ALSO
yum.conf (5) http://yum.baseurl.org/
AUTHORS
See the Authors file included with this program.
BUGS
There are of course no bugs, but should you find any, you should first consult the FAQ section on http://yum.baseurl.org/wiki/Faq and if unsuccessful in finding a resolution contact the mailing list<EMAIL_ADDRESS>To file a bug use http://bugzilla.redhat.com for Fedora/RHEL/Centos related bugs and http://yum.baseurl.org/report for all other bugs.
Index
This document was created by man2html, using the manual pages.
Time: 05:29:10 GMT, December 24, 2015


Current session:
Help
Create a new session
Delete session
Are you sure you want to delete this session
Rename the current session
Import a JSON session
Welcome to the PF2 Encounter planner
It looks like it's your first time here. If so, now that you have a guide
here


Cancel ${subscription.id}
ID
Plan
${subscription.id}
${subscription.plan.id}
Credit
Amount
Refund
Amount
Cancel options
After current billing period
Cancel immediately
Credit ${subscription.plan.amountFormatted} ${subscription.plan.currency} for future payments
Refund ${subscription.plan.amountFormatted} ${subscription.plan.currency} charge to original card
Cancel subscription


Hello everyone my name is Mohammad altaje i'm 28 years old
i have english diploma degree
i had 0 experince in programing skills befor i join this course my gola is to become good enough in programing so
i can get a job
work experice
- i worked as a cctv controler in adidas company for a 1year
- i worked in ice cream store called frosti as a branch maneger for 9 years
Top ten places i wish to visit
- Japan
- Switzerland
- Palestin
- Germany
- Greece
- China
- America
- France
- Italy
- Spain


This is the demo frontend for the Buzzer Recipe in the Crossbar.io IoT Cookbook.
| Connected to URL (protocol) | - |
| Joined as authid@realm | - |
| Addressing Pi with serial No.: | - |
| Pi component started (UTC) | - |
Click one of the buttons to start a beeping sequence on the piezo buzzer connected to the Pi.
When the buzzer on the Pi is active (playing a beep sequence), this indicator is flashed.


Video Player
Adaptive Bitrate Stream Video Player
Responsive Javascript
Responsive Breakpoints
Multiple Video Codec automated
Upload Widget
Media Library Widget


Graphic Artist - Web Designer - Illustrator
The AsepMo Website and Application Is Just an Overview of the Other Side of An AsepMo, Only A Odd Worker. In Between His Free Time. AsepMo Utilizes It To Deepen His Interest In The Programmer World. Initially Only On Website Programming. Then He Is Also Interested In Android Programming That Can Be Implemented In Real Life. At the Beginning of its Learning. He Utilizes Free Facilities and Tools. And AsepMo Hopes to Later Be Able to Use Paid Facilities and Tools to Make the Website and Its Applications Good and Useful.
You can Create Your Own Custom Avatar For The Masthead, Change The Icon In The Dividers, And Add Your Email Address To The Contact Form To Make it Fully Functional!
The AsepMo Website and Application Is Just an Overview of the Other Side of An AsepMo, Only A Odd Worker. In Between His Free Time. AsepMo Utilizes It To Deepen His Interest In The Programmer World. Initially Only On Website Programming. Then He Is Also Interested In Android Programming That Can Be Implemented In Real Life. At the Beginning of its Learning. He Utilizes Free Facilities and Tools. And AsepMo Hopes to Later Be Able to Use Paid Facilities and Tools to Make the Website and Its Applications Good and Useful.
You can Create Your Own Custom Avatar For The Masthead, Change The Icon In The Dividers, And Add Your Email Address To The Contact Form To Make it Fully Functional!
The AsepMo Website and Application Is Just an Overview of the Other Side of An AsepMo, Only A Odd Worker. In Between His Free Time. AsepMo Utilizes It To Deepen His Interest In The Programmer World. Initially Only On Website Programming. Then He Is Also Interested In Android Programming That Can Be Implemented In Real Life. At the Beginning of its Learning. He Utilizes Free Facilities and Tools. And AsepMo Hopes to Later Be Able to Use Paid Facilities and Tools to Make the Website and Its Applications Good and Useful.
You can Create Your Own Custom Avatar For The Masthead, Change The Icon In The Dividers, And Add Your Email Address To The Contact Form To Make it Fully Functional!


Welcome!
Welcome to the System Secure Blog! Here we'll be talking about network security, cybercrime, basic security practice's to ensure users safety across the world-wide web.
Go visit my GitHub website https://www.Github.com to check out other interesting projects. Other website links: https://www.linkedin.com Linkedin. https://www.wordpress.com


September 2022
pdb_diff - Export KeepassXC database to CSV and diff
with idea
command.
pdb_diff
[-h
]
filea fileb
Manually syncing KeePassXC files between two devices is more secure than using a cloud storage for keeping it in sync automatically.
The packaged keepassxc-cli
binary of the KeePassXC
application on macOS supports exporting a KeePassXC database to a CSV
file.
By using a diff tool, one can manually sync the database and then re-import on the second device.
The command creates two temporary files in the working directory of its execution. After exiting the diff tool, you’ll have to hit any key in order to proceed with cleaning them up.
-h
, --help
Prints help
File A (left) which is exported and feeded to the diff tool.
File B (right) which is exported and feeded to the diff tool.
successful execution
error while parsing command line arguments
The command is currently available on macOS platforms only.
Note: Pull requests are welcome to make this more platform agnostic.
no valid keepassxc-cli executable found
This may happen, if the application is not installed within
/Applications
.
Please check, if it is installed within ~/Applications/
and adjust the path in the pdb_diff
command
accordingly.
Note: Pull requests are welcome to make this more agnostic towards installation locations.
$ pdb_diff passwords-desktop.kdbx passwords-mobile.kdbx
idea(1)


Image credits: Google
OWASP
Web Security Tools & Methods
We cannot firewall or patch our way to secure Websites. Security professionals used to think that firewalls, Secure Sockets Layer (SSL), patching, and privacy policies were enough. Today, however, these methods are outdated and ineffective, as attacks on prominent, well-protected Websites are occurring every day. Citigroup, PBS, Sega, Nintendo, Gawker, AT&T, the CIA, the US Senate, NASA, the NYSE, Zynga, and thousands of others have something in common: all of them have had Websites compromised in the last year.
# Top 10 java defenses for website security:
owasp cheat-sheet
1.query parametized;
antomy of a sql
anatomy of a sql injection Attack;
query parameterization in java:
string name = request.getParameter("newName");
string id = request.getParameter("id");
preparedStatement pstmr = con.preparedstatement("update employees set
name=? where id= ?");
pstmt.setStringO( 1 , newName);
pstmt.setString( 2, id);
2. password storage:
store password based on need:
use a salt( de-duplication)
SCRYPT/PBKDF2(slow, peroformance hit,easy)
HMAC(require good key storage, tough)
1.do not limit the type of characters or length of user password
2.use a cryptographically strong credentials-sepcific salt
protect([salt]+[password]);
use a 32 char or 64 char salt
do not depend on hiding,spitting
# 3a) impose difficult verification on the attack(strong/fast)
HMAC-SHA-256[(private key],[salt]+[password])
# 3b) impose difficult verification on attack and defender
PBKDF 2 when FIPS certification
scrypt where resisting any/all hardware
XSS defense cross site scripting:
no third party libraries
more complete api
html contexts xml contexts
# web page built in java JSP is a vulnerable to XSS:
solution:
1)
<input type="text" name="data" value="<%= Encode.forHthmlAttribute(datavalue)%"/>
2)
<textarea name="text"><%= Encode.forHtmlContect(textValue) %"/>
3)
<button
onclick="alert('<%= Encode.forJavascriptAttribute(alertMsg) %>');
click me
</button>
4)
<script type="text/javascript">
var msg="<%= Encode.forJavascriptBlock(message) %>";
alert*msg);
</script>
# html sanitization
# code google owasp java html sanitization
# Bean Validation:
Fields
Properties
Classes
@Constraints
(@Pattern, @Digits, @Min, @Max, @Size, @Past, @Future, @CreditCardNumber, @Email, @URL, etc.)
@Size(min = 10, max = 500)
private String message;
@Past
private Date birthDate;
@Pattern(regexp = "[a-zA-Z0-9 ]", message="article.title.error")
private String articleTitle;
# Implementing input validation:
# Credinital and PII information:
https://cheatsheetseries.owasp.org/cheatsheets/HTML5_Security_Cheat_Sheet.html
<input type="text" spellcheck="false" autocomplete="off" autocorrect="off" autocapitalize="off"></input>
spellcheck="false"
autocomplete="off"
autocorrect="off"
autocapitalize="off"
# WebSocket implementation hints:
Access filtering through the "Origin" HTTP request header
Input / Output validation
Authentication
Authorization
Access token explicit invalidation
Confidentiality and Integrity
# Top 10 Web Application Security Risks
# Injection. Injection flaws, such as SQL, NoSQL, OS, and LDAP injection, occur when untrusted data is sent to an interpreter as part of a command or query. The attacker’s hostile data can trick the interpreter into executing unintended commands or accessing data without proper authorization.
# Broken Authentication. Application functions related to authentication and session management are often implemented incorrectly, allowing attackers to compromise passwords, keys, or session tokens, or to exploit other implementation flaws to assume other users’ identities temporarily or permanently.
# Sensitive Data Exposure. Many web applications and APIs do not properly protect sensitive data, such as financial, healthcare, and PII. Attackers may steal or modify such weakly protected data to conduct credit card fraud, identity theft, or other crimes. Sensitive data may be compromised without extra protection, such as encryption at rest or in transit, and requires special precautions when exchanged with the browser.
# XML External Entities (XXE). Many older or poorly configured XML processors evaluate external entity references within XML documents. External entities can be used to disclose internal files using the file URI handler, internal file shares, internal port scanning, remote code execution, and denial of service attacks.
# Broken Access Control. Restrictions on what authenticated users are allowed to do are often not properly enforced. Attackers can exploit these flaws to access unauthorized functionality and/or data, such as access other users’ accounts, view sensitive files, modify other users’ data, change access rights, etc.
# Security Misconfiguration. Security misconfiguration is the most commonly seen issue. This is commonly a result of insecure default configurations, incomplete or ad hoc configurations, open cloud storage, misconfigured HTTP headers, and verbose error messages containing sensitive information. Not only must all operating systems, frameworks, libraries, and applications be securely configured, but they must be patched/upgraded in a timely fashion.
# Cross-Site Scripting XSS. XSS flaws occur whenever an application includes untrusted data in a new web page without proper validation or escaping, or updates an existing web page with user-supplied data using a browser API that can create HTML or JavaScript. XSS allows attackers to execute scripts in the victim’s browser which can hijack user sessions, deface web sites, or redirect the user to malicious sites.
# Insecure Deserialization. Insecure deserialization often leads to remote code execution. Even if deserialization flaws do not result in remote code execution, they can be used to perform attacks, including replay attacks, injection attacks, and privilege escalation attacks. Using Components with Known Vulnerabilities. Components, such as libraries, frameworks, and other software modules, run with the same
# privileges as the application. If a vulnerable component is exploited, such an attack can facilitate serious data loss or server takeover. Applications and APIs using components with known vulnerabilities may undermine application defenses and enable various attacks and impacts.
# Insufficient Logging & Monitoring. Insufficient logging and monitoring, coupled with missing or ineffective integration with incident response, allows attackers to further attack systems, maintain persistence, pivot to more systems, and tamper, extract, or destroy data. Most breach studies show time to detect a breach is over 200 days, typically detected by external parties rather than internal processes or monitoring.


ClickHouse® is an open-source, high performance columnar OLAP database management system for real-time analytics using SQL.
Our feature rich and hardware efficient OLAP data management system is the right choice for your organization.
ClickHouse supports best in the industry query performance, while significantly reducing storage requirements through our innovative use of columnar storage and compression.
Battle tested in production, with linear horizontal scalability from single-server deployments to clusters with many thousands of nodes.
ClickHouse deployments feature best in class availability. There are no single points of failure, with the architecture supporting multi-master replication, performing effectively in multi-region configurations.
ClickHouse comes with enterprise grade security features and fail-safe mechanisms protecting against data corruption from application bugs and human errors.
ClickHouse was born and in production inside Yandex over a decade ago and now stores 10’s of trillions of rows of data serving a query throughput of 2TB per second for Yandex Metrica. It has also become the de facto standard inside Yandex for advertising systems, monitoring and observability data, business intelligence, recommendations platforms, OLAP, and even cars telemetry.
Read the Case StudyUber moved it’s logging platform to ClickHouse increasing developer productivity and overall reliability of the platform while seeing 3x data compression, 10x performance increase, and ½ the reduction in hardware cost.
Read the Case StudyeBay adopted ClickHouse for their real time OLAP events (Logs + Metrics) infrastructure. The simplified architecture with ClickHouse allowed them to reduce their DevOps activity and troubleshooting, reduced the overall infrastructure by 90%, and they saw a stronger integration with Grafana and ClickHouse for visualization and alerting.
Read the Case StudyCloudflare was having challenges scaling their CitusDB-based system which had a high TCO and maintenance costs due to the complex architecture. By moving their HTTP analytics data to ClickHouse they were able to scale to 8M requests per second, deleted 10’s of thousands of lines of code, reduced their MTTR, and saw a 7x improvement on customer queries per second they could serve.
Read the Case StudySpotify's A/B Experimentation platform is serving thousands of sub-second queries per second on petabyte-scale datasets with Clickhouse. They reduced the amount of low-variance work by an order of magnitude and enabled feature teams to self-serve insights by introducing a unified SQL interface for Data Platform and tools for automatic decision making for Experimentation.
Read the Case StudyClickHouse helps serve the Client Analytics platform for reporting, deep data analysis as well as advanced data science to provide Deutsche Bank’s front office a clear view on their client's activity and profitability.
Read the Case StudyClickHouse's performance exceeds comparable column-oriented database management systems that are available on the market. It processes hundreds of millions to over a billion rows and tens of gigabytes of data per server per second.
Detailed comparison


--- layout: post title: SourceGear Bridge preview: Swift with .NET in Xcode date: 2021-09-21 12:00:00 keywords: swift dotnet front aspnet sgbridge teaser: A demo of a simple web app using Swift, ASP.NET Core 6, and Xcode ---
For quite some time I have been working on various things involving interop between .NET and other ecosystems. If you follow my blog or tweets, you've seen me talk about "Llama", and then "Alpaca", and so on. Generally speaking, I have referred to these efforts as my exploratory projects.
But one of those efforts (the one previously called "Alpaca") is now called "SourceGear Bridge", and the new name reflects our intention to develop this into a production-ready solution with support available. (Note that I'm not saying that it is production-ready now, simply that now we are focused on getting it there.)
In broad brush strokes, we will describe SourceGear Bridge in terms of delivering great interop between .NET and other things. We hope to expand to more languages in the future, but for now the primary focus is Swift. And for that reason, most of my attention lately has been on providing the user experience that Swift developers expect. In other words, everything needs to work well in Xcode on a Mac.
SourceGear Bridge preview release 0.2.0 is now available, and in this blog entry I will walk through a simple demo. This blog entry is written (with an attempt) to be readable by Swift developers who may not know much about .NET.
If you want to follow along on a Mac, you will need Xcode 13, configured to run Swift 5.5 on the command-line. I'm using a MacBook Pro M1 with macOS 11.5.2.
The command-line parts of this demo will work on Linux if you install Swift 5.5. I'm using Ubuntu 20.04 under WSL 2.
And of course you will need the .NET 6 SDK:
https://dotnet.microsoft.com/download/dotnet/6.0
(If you're on a Mac, I recommend using the installer, which I have found to be painless, as compared to the "Binaries".)
For this blog entry, I'm going to start with the command-line for a while and then switch to Xcode a bit later.
The .NET command-line interface is called dotnet
, and its
basic design is similar to the swift
command-line interface,
where the first argument is the name of a command.
Building with .NET? Use dotnet build
.
Building with Swift? Use swift build
.
To create a new web project with .NET,
you would use dotnet new
:
mkdir foo cd foo dotnet new web -lang C#
(The -lang C#
argument is usually optional because
it's the default language for .NET.)
This will result in several files being generated.
The two important ones are foo.csproj
(the project
file) and Program.cs
(the source file).
You can take a look at these files if you like, but I just wanted to mention them and move on to focus on how to create the equivalent project in Swift.
Many things about the .NET command-line interface
can be customized, including support for other languages.
So the first thing we want to do here is to install
some templates to let dotnet
know about Swift:
dotnet new --install sourcegear.bridge.swift.templates
In the command just above, sourcegear.bridge.swift.templates
is the ID of a package on nuget.org
. NuGet is the package
manager for .NET.
Having installed the templates, we can can list the available templates like this:
dotnet new --list
You should see a bunch of built-in templates, plus a couple of new ones for the Swift language.
Let's use one of those templates to create the same project we did above, except now in Swift:
mkdir bar cd bar dotnet new web -lang Swift
This should create three things:
bar.swiftproj Package.swift Sources/
The presence of the Package.swift
file indicates that this
directory is now a SwiftPM package, and can be used with any
Swift tooling that supports Swift Package Manager, including the swift
command-line tool as well as Xcode.
(For .NET devs: Package.swift
looks like a Swift
source file but it's actually a project file, the equivalent of
a csproj
. It uses Swift syntax, but don't think of
it as Swift code.)
The presence of the bar.swiftproj
file means that this
directory is also a .NET project, and can be used with
the dotnet
command-line interface as well.
This file is the Swift equivalent of the
foo.csproj
file. It's in an XML-based format called MSBuild,
but Swift developers shouldn't need to worry about that. A typical
MSBuild file has lots of settings and properties and targets and
tasks. But in this case,
what this file does is explain to MSBuild how to get the information it
needs from Package.swift
instead.
The source code for project is in the
Sources/
directory, just as one would expect for a
Swift package. We'll take a look at the code itself
later when we open it up in Xcode.
But let's peek briefy inside Package.swift
, where we
see this:
dependencies: [ .package( name: "sourcegear-bridge-aspnetcore", url: "https://github.com/sourcegear/sourcegear-bridge-aspnetcore", .exact("0.2.0") ), ],
The bindings for .NET 6 and ASP.NET Core 6 are in the form of
Swift packages, hosted on GitHub. The sourcegear-bridge-aspnetcore
package contains the bindings for ASP.NET Core. The sourcegear-bridge-dotnet
package
contains the bindings for the .NET 6 base class library.
(For .NET devs: A Swift package is a git repo, specifed by a URL, plus information about what tag/branch/commit to use. Yes, really. Given your experience with nuget and the connotations of the word "package", you're going to be looking for a single-file format which is actually a zip. It's not there. Also, there is no central package registry, but the Swift community seems to be working on that.)
Continuing on the command-line a bit more, try running swift build
.
The first time you build the project
will take longer because it has to compile all the bindings.
The result of the build should appear as a shared library (on Mac, a dylib) in
.build/debug/
.
The compilation model here is to build the Swift code into a shared library. Then the tooling generates a trivial .NET host program that (1) initializes the bindings so that Swift can call .NET APIs, and (2) passes control to the the Swift code.
Now we can do dotnet run
and you should see messages indicating
that the web server is running on port 5000:
eric@Erics-MacBook-Pro bar % dotnet run info: Microsoft.Hosting.Lifetime[14] Now listening on: http://localhost:5000 info: Microsoft.Hosting.Lifetime[14] Now listening on: https://localhost:5001 info: Microsoft.Hosting.Lifetime[0] Application started. Press Ctrl+C to shut down. info: Microsoft.Hosting.Lifetime[0] Hosting environment: Production info: Microsoft.Hosting.Lifetime[0] Content root path: /Users/eric/bar
And you should be able to go to a browser and access http://localhost:5000/
to see: Hello World!
Okay, let's try opening the Package.swift
file in Xcode,
either from Finder, or from the command-line, like this:
open Package.swift
Here in Xcode, things should mostly work as you would expect, like any other Swift project, with syntax coloring and code completion and other niceties.
Most .NET APIs have documentation comments, and that information is propagated through the bindings to make it available with Xcode Quick Help:
Code completion is especially helpful for a framework like ASP.NET Core, which has many features and a large surface area:
Looking at Program.swift
, there are import
declarations, typealias
declarations, some
error handling, and a function declaration, but the essence of the matter is the following snippet:
let app = try WebApplication.Create() try app.MapGet( pattern: "/", handler: Func{ () -> System.String in "Hello World!" } ); try app.Run();
Three API calls:
One to create the web app
One to set things up
One to run it
The most interesting call here is the second one, the call to MapGet(pattern:handler:)
,
which basically says "when somebody accesses the root URL, run this closure, which returns a string".
One thing you might notice is that the C# version is more concise than its Swift equivalent. Both are using the same 3 API calls from the so-called "minimal" APIs which are new in ASP.NET Core 6. See the recent blog entry by Scott Hanselman:
https://www.hanselman.com/blog/minimal-apis-at-a-glance-in-net-6
But currently the Swift incarnation ends up more verbose. There are some things we can do in the future to make things tighter. For example, we can move a bunch of the boilerplate from the source file into the SDK, which is (in part) how ASP.NET Core minimal APIs work anyway. A full explanation would fill another blog entry, but for now I'll highlight a few of the ways that the Swift and C# code differ:
It is common in Swift to use named parameters. The MapGet()
call shows this, with pattern:
and handler:
labels for its arguments.
The handler:
argument for MapGet(pattern:handler:)
is a Swift closure (converted to a .NET delegate). In the C# version, the lambda is shorter, because it makes use of a new C# 10 compiler feature to infer delegate types.
Swift doesn't have namespaces. We cope with this limitation by using nested types (which kinda works), and the Swift typealias
feature (which is actually quite powerful). I still want real namespaces BTW.
(For .NET devs: I'd like to clarify that despite what you see in this code, Swift does not have exceptions. Swift error handling uses the terminology of try
and catch
, but it all happens within one function; no stack unwinding involved.)
The binding generator currently declares every Swift wrapper function as throws
, because it assumes the underlying .NET method might throw an exception which needs to be propagated. I have a few thoughts on how this might get smarter in the future, but for now, every call to a .NET function is preceded with try
.
We have lots to do as we move SourceGear Bridge toward a production-ready release. Here are a few things that are in progress but not yet finished:
F#-style object expressions
Support for async/await (new in Swift 5.5)
Fix handling of formatting and other inline tags in documentation comments
Automatic generation of bindings for nuget packages
Test this stuff on Windows and see if it works
Samples. Need. Samples.


@import security.Roles._ @(usr: CachedData)(implicit request: Request[_], flash: Flash, user: Option[CachedData], feedbackUrl: String) @if(WithdrawnApplicationRole.isAuthorized(usr)) {
Your application has been withdrawn.
If you believe there's been a mistake, please contact us.


{% load static i18n %}
Please note that this portal is in early development. Bugs may be present. If you run into any issues, email<EMAIL_ADDRESS>and we'll get them sorted out as soon as possible.
Welcome to the OLC Webportal
A variety of tools are available. Click on a tool to see its description.


--- layout: post status: publish published: true title: "破碎,然后失眠..." author: Leask author_login: leask author_email<EMAIL_ADDRESS>author_url: https://leaskh.com wordpress_id: 533 wordpress_url: http://leaskh.wordpress.com/2006/06/12/%e7%a0%b4%e7%a2%8e%e7%84%b6%e5%90%8e%e5%a4%b1%e7%9c%a0 date: '2006-06-12 17:25:54 +0800' date_gmt: '2006-06-12 17:25:54 +0800' categories: - Life tags: [] comments: - id: 300 author: Charles author_email: '' author_url: '' date: '2006-06-13 13:34:45 +0800' date_gmt: '2006-06-13 13:34:45 +0800' content: thats a col picture ,, it looks almost like a classroom behind the curtain with the wedge removed ---


| Extra small devices Phones (<768px) | Small devices Tablets (≥768px) | Medium devices Desktops (≥992px) | Large devices Desktops (≥1200px) | |
|---|---|---|---|---|
| Grid behavior | Horizontal at all times | Collapsed to start, horizontal above breakpoints | ||
| Max container width | None (auto) | 750px | 970px | 1170px |
| Class prefix |
.col-xs-
|
.col-sm-
|
.col-md-
|
.col-lg-
|
| # of columns | 12 | |||
| Max column width | Auto | 60px | 78px | 95px |
| Gutter width | 30px (15px on each side of a column) | |||
| Nestable | Yes | |||
| Offsets | Yes | |||
| Column ordering | Yes |
Pages are made responsive by including .col-xs-*
for extra small devices, .col-sm-*
for small devices (tablets), .col-md-*
for medium devices and .col-lg-*
for large devices.


You're not sure how it got so far in this cave.  Sleighs won't be invented for another 1500 years, of course.
The only option is experimental emergency teleportation.
You hit the "experimental emergency teleportation" button on
the device and push I accept the risk on no fewer than 18 different warning messages. Immediately, the device deploys hundreds of tiny nanobots
which fly around the cavern, apparently assembling themselves into a very specific formation. The device lists the X,Y,Z
position
(pos
) for each nanobot as well as its signal radius (r
) on its tiny screen (your puzzle input).
Each nanobot can transmit signals to any integer coordinate which is a distance away from it less than or equal to its signal radius (as measured by Manhattan distance). Coordinates a distance away of less than or equal to a nanobot's signal radius are said to be in range of that nanobot.
Before you start the teleportation process, you should determine which nanobot is the strongest (that is, which has the largest signal radius) and then, for that nanobot, the total number of nanobots that are in range of it, including itself.
For example, given the following nanobots:
pos=<0,0,0>, r=4
pos=<1,0,0>, r=1
pos=<4,0,0>, r=3
pos=<0,2,0>, r=1
pos=<0,5,0>, r=3
pos=<0,0,3>, r=1
pos=<1,1,1>, r=1
pos=<1,1,2>, r=1
pos=<1,3,1>, r=1
The strongest nanobot is the first one (position 0,0,0
) because its signal radius, 4
is the largest. Using that nanobot's
location and signal radius, the following nanobots are in or out of range:
- The nanobot at
0,0,0
is distance0
away, and so it is in range. - The nanobot at
1,0,0
is distance1
away, and so it is in range. - The nanobot at
4,0,0
is distance4
away, and so it is in range. - The nanobot at
0,2,0
is distance2
away, and so it is in range. - The nanobot at
0,5,0
is distance5
away, and so it is not in range. - The nanobot at
0,0,3
is distance3
away, and so it is in range. - The nanobot at
1,1,1
is distance3
away, and so it is in range. - The nanobot at
1,1,2
is distance4
away, and so it is in range. - The nanobot at
1,3,1
is distance5
away, and so it is not in range.
In this example, in total, 7
nanobots are in range of the nanobot with the largest signal radius.
Find the nanobot with the largest signal radius. How many nanobots are in range of its signals?


This form is unsubmittable due to a non-null blob column.
Note: Data created in preview mode won't be available after a refresh.


# This file is part of QuTiP: Quantum Toolbox in Python.
#
# Copyright (c) 2011 and later, Paul D. Nation and Robert J. Johansson.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met:
#
# 1. Redistributions of source code must retain the above copyright notice,
# this list of conditions and the following disclaimer.
#
# 2. Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
#
# 3. Neither the name of the QuTiP: Quantum Toolbox in Python nor the names
# of its contributors may be used to endorse or promote products derived
# from this software without specific prior written permission.
 IN NO EVENT SHALL THE COPYRIGHT
# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
###############################################################################
__all__ = ['correlation_2op_1t', 'correlation_2op_2t', 'correlation_3op_1t',
'correlation_3op_2t', 'coherence_function_g1',
'coherence_function_g2', 'spectrum', 'spectrum_correlation_fft',
'correlation_ss', 'correlation', 'correlation_4op_1t',
'correlation_4op_2t', 'spectrum_ss', 'spectrum_pi']
from re import sub
from warnings import warn
import types
import numpy as np
import scipy.fftpack
from qutip.eseries import esval, esspec
from qutip.essolve import ode2es
from qutip.expect import expect
from qutip.mesolve import mesolve
from qutip.mcsolve import mcsolve
from qutip.operators import qeye
from qutip.qobj import Qobj, isket, issuper
from qutip.rhs_generate import rhs_clear, _td_wrap_array_str
from qutip.cy.utilities import _cython_build_cleanup
from qutip.settings import debug
from qutip.solver import Options, config
from qutip.steadystate import steadystate
from qutip.states import ket2dm
from qutip.superoperator import liouvillian, spre, mat2vec
from qutip.tensor import tensor
if debug:
import inspect
# -----------------------------------------------------------------------------
# PUBLIC API
# -----------------------------------------------------------------------------
# low level correlation
[docs]def correlation_2op_1t(H, state0, taulist, c_ops, a_op, b_op,
solver="me", reverse=False, args={},
options=Options(ntraj=[20, 100])):
"""
Calculate the two-operator two-time correlation function:
:math:`\left<A(t+\\tau)B(t)\\right>`
along one time axis using the quantum regression theorem and the evolution
solver indicated by the `solver` parameter.
Parameters
----------
H : Qobj
system Hamiltonian, may be time-dependent for solver choice of `me` or
`mc`.
state0 : Qobj
Initial state density matrix :math:`\\rho(t_0)` or state vector
:math:`\\psi(t_0)`. If 'state0' is 'None', then the steady state will
be used as the initial state. The 'steady-state' is only implemented
for the `me` and `es` solvers.
taulist : array_like
list of times for :math:`\\tau`. taulist must be positive and contain
the element `0`.
c_ops : list
list of collapse operators, may be time-dependent for solver choice of
`me` or `mc`.
a_op : Qobj
operator A.
b_op : Qobj
operator B.
reverse : bool {False, True}
If `True`, calculate :math:`\left<A(t)B(t+\\tau)\\right>` instead of
:math:`\left<A(t+\\tau)B(t)\\right>`.
solver : str {'me', 'mc', 'es'}
choice of solver (`me` for master-equation, `mc` for Monte Carlo, and
`es` for exponential series).
options : Options
Solver options class. `ntraj` is taken as a two-element list because
the `mc` correlator calls `mcsolve()` recursively; by default,
`ntraj=[20, 100]`. `mc_corr_eps` prevents divide-by-zero errors in
the `mc` correlator; by default, `mc_corr_eps=1e-10`.
Returns
-------
corr_vec : ndarray
An array of correlation values for the times specified by `tlist`.
References
----------
See, Gardiner, Quantum Noise, Section 5.2.
"""
if debug:
print(inspect.stack()[0][3])
if reverse:
A_op = a_op
B_op = b_op
C_op = 1
else:
A_op = 1
B_op = a_op
C_op = b_op
return _correlation_2t(H, state0, [0], taulist, c_ops, A_op, B_op, C_op,
solver=solver, args=args, options=options)[0]
[docs]def correlation_2op_2t(H, state0, tlist, taulist, c_ops, a_op, b_op,
solver="me", reverse=False, args={},
options=Options(ntraj=[20, 100])):
"""
Calculate the two-operator two-time correlation function:
:math:`\left<A(t+\\tau)B(t)\\right>`
along two time axes using the quantum regression theorem and the
evolution solver indicated by the `solver` parameter.
Parameters
----------
H : Qobj
system Hamiltonian, may be time-dependent for solver choice of `me` or
`mc`.
state0 : Qobj
Initial state density matrix :math:`\\rho_0` or state vector
:math:`\\psi_0`. If 'state0' is 'None', then the steady state will
be used as the initial state. The 'steady-state' is only implemented
for the `me` and `es` solvers.
tlist : array_like
list of times for :math:`t`. tlist must be positive and contain the
element `0`. When taking steady-steady correlations only one tlist
value is necessary, i.e. when :math:`t \\rightarrow \\infty`; here
tlist is automatically set, ignoring user input.
taulist : array_like
list of times for :math:`\\tau`. taulist must be positive and contain
the element `0`.
c_ops : list
list of collapse operators, may be time-dependent for solver choice of
`me` or `mc`.
a_op : Qobj
operator A.
b_op : Qobj
operator B.
reverse : bool {False, True}
If `True`, calculate :math:`\left<A(t)B(t+\\tau)\\right>` instead of
:math:`\left<A(t+\\tau)B(t)\\right>`.
solver : str
choice of solver (`me` for master-equation, `mc` for Monte Carlo, and
`es` for exponential series).
options : Options
solver options class. `ntraj` is taken as a two-element list because
the `mc` correlator calls `mcsolve()` recursively; by default,
`ntraj=[20, 100]`. `mc_corr_eps` prevents divide-by-zero errors in
the `mc` correlator; by default, `mc_corr_eps=1e-10`.
Returns
-------
corr_mat : ndarray
An 2-dimensional array (matrix) of correlation values for the times
specified by `tlist` (first index) and `taulist` (second index). If
`tlist` is `None`, then a 1-dimensional array of correlation values
is returned instead.
References
----------
See, Gardiner, Quantum Noise, Section 5.2.
"""
if debug:
print(inspect.stack()[0][3])
if tlist is None:
return correlation_2op_1t(H, state0, taulist, c_ops, a_op, b_op,
solver=solver, reverse=reverse, args=args,
options=options)
else:
if reverse:
A_op = a_op
B_op = b_op
C_op = 1
else:
A_op = 1
B_op = a_op
C_op = b_op
return _correlation_2t(H, state0, tlist, taulist,
c_ops, A_op, B_op, C_op,
solver=solver, args=args, options=options)
[docs]def correlation_3op_1t(H, state0, taulist, c_ops, a_op, b_op, c_op,
solver="me", args={},
options=Options(ntraj=[20, 100])):
"""
Calculate the three-operator two-time correlation function:
:math:`\left<A(t)B(t+\\tau)C(t)\\right>`
along one time axis using the quantum regression theorem and the
evolution solver indicated by the `solver` parameter.
Note: it is not possibly to calculate a physically meaningful correlation
of this form where :math:`\\tau<0`.
Parameters
----------
H : Qobj
system Hamiltonian, may be time-dependent for solver choice of `me` or
`mc`.
rho0 : Qobj
Initial state density matrix :math:`\\rho(t_0)` or state vector
:math:`\\psi(t_0)`. If 'state0' is 'None', then the steady state will
be used as the initial state. The 'steady-state' is only implemented
for the `me` and `es` solvers.
taulist : array_like
list of times for :math:`\\tau`. taulist must be positive and contain
the element `0`.
c_ops : list
list of collapse operators, may be time-dependent for solver choice of
`me` or `mc`.
a_op : Qobj
operator A.
b_op : Qobj
operator B.
c_op : Qobj
operator C.
solver : str
choice of solver (`me` for master-equation, `mc` for Monte Carlo, and
`es` for exponential series).
options : Options
solver options class. `ntraj` is taken as a two-element list because
the `mc` correlator calls `mcsolve()` recursively; by default,
`ntraj=[20, 100]`. `mc_corr_eps` prevents divide-by-zero errors in
the `mc` correlator; by default, `mc_corr_eps=1e-10`.
Returns
-------
corr_vec : array
An array of correlation values for the times specified by `taulist`
References
----------
See, Gardiner, Quantum Noise, Section 5.2.
"""
if debug:
print(inspect.stack()[0][3])
return _correlation_2t(H, state0, [0], taulist, c_ops, a_op, b_op, c_op,
solver=solver, args=args, options=options)[0]
[docs]def correlation_3op_2t(H, state0, tlist, taulist, c_ops, a_op, b_op, c_op,
solver="me", args={},
options=Options(ntraj=[20, 100])):
"""
Calculate the three-operator two-time correlation function:
:math:`\left<A(t)B(t+\\tau)C(t)\\right>`
along two time axes using the quantum regression theorem and the
evolution solver indicated by the `solver` parameter.
Note: it is not possibly to calculate a physically meaningful correlation
of this form where :math:`\\tau<0`.
Parameters
----------
H : Qobj
system Hamiltonian, may be time-dependent for solver choice of `me` or
`mc`.
rho0 : Qobj
Initial state density matrix :math:`\\rho_0` or state vector
:math:`\\psi_0`. If 'state0' is 'None', then the steady state will
be used as the initial state. The 'steady-state' is only implemented
for the `me` and `es` solvers.
tlist : array_like
list of times for :math:`t`. tlist must be positive and contain the
element `0`. When taking steady-steady correlations only one tlist
value is necessary, i.e. when :math:`t \\rightarrow \\infty`; here
tlist is automatically set, ignoring user input.
taulist : array_like
list of times for :math:`\\tau`. taulist must be positive and contain
the element `0`.
c_ops : list
list of collapse operators, may be time-dependent for solver choice of
`me` or `mc`.
a_op : Qobj
operator A.
b_op : Qobj
operator B.
c_op : Qobj
operator C.
solver : str
choice of solver (`me` for master-equation, `mc` for Monte Carlo, and
`es` for exponential series).
options : Options
solver options class. `ntraj` is taken as a two-element list because
the `mc` correlator calls `mcsolve()` recursively; by default,
`ntraj=[20, 100]`. `mc_corr_eps` prevents divide-by-zero errors in
the `mc` correlator; by default, `mc_corr_eps=1e-10`.
Returns
-------
corr_mat : array
An 2-dimensional array (matrix) of correlation values for the times
specified by `tlist` (first index) and `taulist` (second index). If
`tlist` is `None`, then a 1-dimensional array of correlation values
is returned instead.
References
----------
See, Gardiner, Quantum Noise, Section 5.2.
"""
if debug:
print(inspect.stack()[0][3])
if tlist is None:
return correlation_3op_1t(H, state0, taulist, c_ops, a_op, b_op, c_op,
solver=solver, args=args, options=options)
else:
return _correlation_2t(H, state0, tlist, taulist,
c_ops, a_op, b_op, c_op,
solver=solver, args=args, options=options)
# high level correlation
[docs]def coherence_function_g1(H, state0, taulist, c_ops, a_op, solver="me",
args={}, options=Options(ntraj=[20, 100])):
"""
Calculate the normalized first-order quantum coherence function:
.. math::
g^{(1)}(\\tau) =
\\frac{\\langle A^\\dagger(\\tau)A(0)\\rangle}
{\\sqrt{\\langle A^\\dagger(\\tau)A(\\tau)\\rangle
\\langle A^\\dagger(0)A(0)\\rangle}}
using the quantum regression theorem and the evolution solver indicated by
the `solver` parameter.
Parameters
----------
H : Qobj
system Hamiltonian, may be time-dependent for solver choice of `me` or
`mc`.
state0 : Qobj
Initial state density matrix :math:`\\rho(t_0)` or state vector
:math:`\\psi(t_0)`. If 'state0' is 'None', then the steady state will
be used as the initial state. The 'steady-state' is only implemented
for the `me` and `es` solvers.
taulist : array_like
list of times for :math:`\\tau`. taulist must be positive and contain
the element `0`.
c_ops : list
list of collapse operators, may be time-dependent for solver choice of
`me` or `mc`.
a_op : Qobj
operator A.
solver : str
choice of solver (`me` for master-equation and
`es` for exponential series).
options : Options
solver options class. `ntraj` is taken as a two-element list because
the `mc` correlator calls `mcsolve()` recursively; by default,
`ntraj=[20, 100]`. `mc_corr_eps` prevents divide-by-zero errors in
the `mc` correlator; by default, `mc_corr_eps=1e-10`.
Returns
-------
g1, G1 : tuple
The normalized and unnormalized second-order coherence function.
"""
# first calculate the photon number
if state0 is None:
state0 = steadystate(H, c_ops)
n = np.array([expect(state0, a_op.dag() * a_op)])
else:
n = mesolve(H, state0, taulist, c_ops, [a_op.dag() * a_op],
options=options).expect[0]
# calculate the correlation function G1 and normalize with n to obtain g1
G1 = correlation_2op_1t(H, state0, taulist, c_ops, a_op.dag(), a_op,
solver=solver, args=args, options=options)
g1 = G1 / np.sqrt(n[0] * n)
return g1, G1
[docs]def coherence_function_g2(H, state0, taulist, c_ops, a_op, solver="me", args={},
options=Options(ntraj=[20, 100])):
"""
Calculate the normalized second-order quantum coherence function:
.. math::
g^{(2)}(\\tau) =
\\frac{\\langle A^\\dagger(0)A^\\dagger(\\tau)A(\\tau)A(0)\\rangle}
{\\langle A^\\dagger(\\tau)A(\\tau)\\rangle
\\langle A^\\dagger(0)A(0)\\rangle}
using the quantum regression theorem and the evolution solver indicated by
the `solver` parameter.
Parameters
----------
H : Qobj
system Hamiltonian, may be time-dependent for solver choice of `me` or
`mc`.
state0 : Qobj
Initial state density matrix :math:`\\rho(t_0)` or state vector
:math:`\\psi(t_0)`. If 'state0' is 'None', then the steady state will
be used as the initial state. The 'steady-state' is only implemented
for the `me` and `es` solvers.
taulist : array_like
list of times for :math:`\\tau`. taulist must be positive and contain
the element `0`.
c_ops : list
list of collapse operators, may be time-dependent for solver choice of
`me` or `mc`.
a_op : Qobj
operator A.
solver : str
choice of solver (`me` for master-equation and
`es` for exponential series).
options : Options
solver options class. `ntraj` is taken as a two-element list because
the `mc` correlator calls `mcsolve()` recursively; by default,
`ntraj=[20, 100]`. `mc_corr_eps` prevents divide-by-zero errors in
the `mc` correlator; by default, `mc_corr_eps=1e-10`.
Returns
-------
g2, G2 : tuple
The normalized and unnormalized second-order coherence function.
"""
# first calculate the photon number
if state0 is None:
state0 = steadystate(H, c_ops)
n = np.array([expect(state0, a_op.dag() * a_op)])
else:
n = mesolve(H, state0, taulist, c_ops, [a_op.dag() * a_op]).expect[0]
# calculate the correlation function G2 and normalize with n to obtain g2
G2 = correlation_3op_1t(H, state0, taulist, c_ops,
a_op.dag(), a_op.dag()*a_op, a_op,
solver=solver, args=args, options=options)
g2 = G2 / (n[0] * n)
return g2, G2
# spectrum
[docs]def spectrum(H, wlist, c_ops, a_op, b_op, solver="es", use_pinv=False):
"""
Calculate the spectrum of the correlation function
:math:`\lim_{t \\to \\infty} \left<A(t+\\tau)B(t)\\right>`,
i.e., the Fourier transform of the correlation function:
.. math::
S(\omega) = \int_{-\infty}^{\infty}
\lim_{t \\to \\infty} \left<A(t+\\tau)B(t)\\right>
e^{-i\omega\\tau} d\\tau.
using the solver indicated by the `solver` parameter. Note: this spectrum
is only defined for stationary statistics (uses steady state rho0)
Parameters
----------
H : :class:`qutip.qobj`
system Hamiltonian.
wlist : array_like
list of frequencies for :math:`\\omega`.
c_ops : list
list of collapse operators.
a_op : Qobj
operator A.
b_op : Qobj
operator B.
solver : str
choice of solver (`es` for exponential series and
`pi` for psuedo-inverse).
use_pinv : bool
For use with the `pi` solver: if `True` use numpy's pinv method,
otherwise use a generic solver.
Returns
-------
spectrum : array
An array with spectrum :math:`S(\omega)` for the frequencies
specified in `wlist`.
"""
if debug:
print(inspect.stack()[0][3])
if solver == "es":
return _spectrum_es(H, wlist, c_ops, a_op, b_op)
elif solver == "pi":
return _spectrum_pi(H, wlist, c_ops, a_op, b_op, use_pinv)
else:
raise ValueError("Unrecognized choice of solver" +
"%s (use es or pi)." % solver)
[docs]def spectrum_correlation_fft(taulist, y):
"""
Calculate the power spectrum corresponding to a two-time correlation
function using FFT.
Parameters
----------
tlist : array_like
list/array of times :math:`t` which the correlation function is given.
y : array_like
list/array of correlations corresponding to time delays :math:`t`.
Returns
-------
w, S : tuple
Returns an array of angular frequencies 'w' and the corresponding
one-sided power spectrum 'S(w)'.
"""
if debug:
print(inspect.stack()[0][3])
N = len(taulist)
dt = taulist[1] - taulist[0]
F = scipy.fftpack.fft(y)
# calculate the frequencies for the components in F
f = scipy.fftpack.fftfreq(N, dt)
# select only indices for elements that corresponds
# to positive frequencies
indices = np.where(f > 0.0)
return 2 * np.pi * f[indices], 2 * dt * np.real(F[indices])
# -----------------------------------------------------------------------------
# LEGACY API
# -----------------------------------------------------------------------------
# low level correlation
[docs]def correlation_ss(H, taulist, c_ops, a_op, b_op,
solver="me", reverse=False, args={},
options=Options(ntraj=[20, 100])):
"""
Calculate the two-operator two-time correlation function:
.. math::
\lim_{t \\to \\infty} \left<A(t+\\tau)B(t)\\right>
along one time axis (given steady-state initial conditions) using the
quantum regression theorem and the evolution solver indicated by the
`solver` parameter.
Parameters
----------
H : Qobj
system Hamiltonian.
taulist : array_like
list of times for :math:`\\tau`. taulist must be positive and contain
the element `0`.
c_ops : list
list of collapse operators.
a_op : Qobj
operator A.
b_op : Qobj
operator B.
reverse : *bool*
If `True`, calculate
:math:`\lim_{t \\to \\infty} \left<A(t)B(t+\\tau)\\right>` instead of
:math:`\lim_{t \\to \\infty} \left<A(t+\\tau)B(t)\\right>`.
solver : str
choice of solver (`me` for master-equation and
`es` for exponential series).
options : Options
solver options class. `ntraj` is taken as a two-element list because
the `mc` correlator calls `mcsolve()` recursively; by default,
`ntraj=[20, 100]`. `mc_corr_eps` prevents divide-by-zero errors in
the `mc` correlator; by default, `mc_corr_eps=1e-10`.
Returns
-------
corr_vec : array
An array of correlation values for the times specified by `tlist`.
References
----------
See, Gardiner, Quantum Noise, Section 5.2.
"""
warn("correlation_ss() now legacy, please use correlation_2op_1t() with" +
"initial state as None", FutureWarning)
if debug:
print(inspect.stack()[0][3])
return correlation_2op_1t(H, None, taulist, c_ops, a_op, b_op,
solver=solver, reverse=reverse, args=args,
options=options)
[docs]def correlation(H, state0, tlist, taulist, c_ops, a_op, b_op,
solver="me", reverse=False, args={},
options=Options(ntraj=[20, 100])):
"""
Calculate the two-operator two-time correlation function:
:math:`\left<A(t+\\tau)B(t)\\right>`
along two time axes using the quantum regression theorem and the
evolution solver indicated by the `solver` parameter.
Parameters
----------
H : Qobj
system Hamiltonian, may be time-dependent for solver choice of `me` or
`mc`.
state0 : Qobj
Initial state density matrix :math:`\\rho(t_0)` or state vector
:math:`\\psi(t_0)`. If 'state0' is 'None', then the steady state will
be used as the initial state. The 'steady-state' is only implemented
for the `me` and `es` solvers.
tlist : array_like
list of times for :math:`t`. tlist must be positive and contain the
element `0`. When taking steady-steady correlations only one tlist
value is necessary, i.e. when :math:`t \\rightarrow \\infty`; here
tlist is automatically set, ignoring user input.
taulist : array_like
list of times for :math:`\\tau`. taulist must be positive and contain
the element `0`.
c_ops : list
list of collapse operators, may be time-dependent for solver choice of
`me` or `mc`.
a_op : Qobj
operator A.
b_op : Qobj
operator B.
reverse : *bool*
If `True`, calculate :math:`\left<A(t)B(t+\\tau)\\right>` instead of
:math:`\left<A(t+\\tau)B(t)\\right>`.
solver : str
choice of solver (`me` for master-equation, `mc` for Monte Carlo, and
`es` for exponential series).
options : Options
solver options class. `ntraj` is taken as a two-element list because
the `mc` correlator calls `mcsolve()` recursively; by default,
`ntraj=[20, 100]`. `mc_corr_eps` prevents divide-by-zero errors in
the `mc` correlator; by default, `mc_corr_eps=1e-10`.
Returns
-------
corr_mat : array
An 2-dimensional array (matrix) of correlation values for the times
specified by `tlist` (first index) and `taulist` (second index). If
`tlist` is `None`, then a 1-dimensional array of correlation values
is returned instead.
References
----------
See, Gardiner, Quantum Noise, Section 5.2.
"""
warn("correlation() now legacy, please use correlation_2op_2t()",
FutureWarning)
if debug:
print(inspect.stack()[0][3])
return correlation_2op_2t(H, state0, tlist, taulist, c_ops, a_op, b_op,
solver=solver, reverse=reverse, args=args,
options=options)
[docs]def correlation_4op_1t(H, state0, taulist, c_ops, a_op, b_op, c_op, d_op,
solver="me", args={},
options=Options(ntraj=[20, 100])):
"""
Calculate the four-operator two-time correlation function:
:math:`\left<A(t)B(t+\\tau)C(t+\\tau)D(t)\\right>`
along one time axis using the quantum regression theorem and the
evolution solver indicated by the `solver` parameter.
Note: it is not possibly to calculate a physically meaningful correlation
of this form where :math:`\\tau<0`.
Parameters
----------
H : Qobj
system Hamiltonian, may be time-dependent for solver choice of `me` or
`mc`.
rho0 : Qobj
Initial state density matrix :math:`\\rho(t_0)` or state vector
:math:`\\psi(t_0)`. If 'state0' is 'None', then the steady state will
be used as the initial state. The 'steady-state' is only implemented
for the `me` and `es` solvers.
taulist : array_like
list of times for :math:`\\tau`. taulist must be positive and contain
the element `0`.
c_ops : list
list of collapse operators, may be time-dependent for solver choice of
`me` or `mc`.
a_op : Qobj
operator A.
b_op : Qobj
operator B.
c_op : Qobj
operator C.
d_op : Qobj
operator D.
solver : str
choice of solver (`me` for master-equation, `mc` for Monte Carlo, and
`es` for exponential series).
options : Options
solver options class. `ntraj` is taken as a two-element list because
the `mc` correlator calls `mcsolve()` recursively; by default,
`ntraj=[20, 100]`. `mc_corr_eps` prevents divide-by-zero errors in
the `mc` correlator; by default, `mc_corr_eps=1e-10`.
Returns
-------
corr_vec : array
An array of correlation values for the times specified by `taulist`.
References
----------
See, Gardiner, Quantum Noise, Section 5.2.
.. note:: Deprecated in QuTiP 3.1
Use correlation_3op_1t() instead.
"""
warn("correlation_4op_1t() now legacy, please use correlation_3op_1t()",
FutureWarning)
warn("the reverse argument has been removed as it did not contain any" +
"new physical information", DeprecationWarning)
if debug:
print(inspect.stack()[0][3])
return correlation_3op_1t(H, state0, taulist, c_ops,
a_op, b_op * c_op, d_op,
solver=solver, args=args, options=options)
[docs]def correlation_4op_2t(H, state0, tlist, taulist, c_ops,
a_op, b_op, c_op, d_op, solver="me", args={},
options=Options(ntraj=[20, 100])):
"""
Calculate the four-operator two-time correlation function:
:math:`\left<A(t)B(t+\\tau)C(t+\\tau)D(t)\\right>`
along two time axes using the quantum regression theorem and the
evolution solver indicated by the `solver` parameter.
Note: it is not possibly to calculate a physically meaningful correlation
of this form where :math:`\\tau<0`.
Parameters
----------
H : Qobj
system Hamiltonian, may be time-dependent for solver choice of `me` or
`mc`.
rho0 : Qobj
Initial state density matrix :math:`\\rho_0` or state vector
:math:`\\psi_0`. If 'state0' is 'None', then the steady state will
be used as the initial state. The 'steady-state' is only implemented
for the `me` and `es` solvers.
tlist : array_like
list of times for :math:`t`. tlist must be positive and contain the
element `0`. When taking steady-steady correlations only one tlist
value is necessary, i.e. when :math:`t \\rightarrow \\infty`; here
tlist is automatically set, ignoring user input.
taulist : array_like
list of times for :math:`\\tau`. taulist must be positive and contain
the element `0`.
c_ops : list
list of collapse operators, may be time-dependent for solver choice of
`me` or `mc`.
a_op : Qobj
operator A.
b_op : Qobj
operator B.
c_op : Qobj
operator C.
d_op : Qobj
operator D.
solver : str
choice of solver (`me` for master-equation, `mc` for Monte Carlo, and
`es` for exponential series).
options : Options
solver options class. `ntraj` is taken as a two-element list because
the `mc` correlator calls `mcsolve()` recursively; by default,
`ntraj=[20, 100]`. `mc_corr_eps` prevents divide-by-zero errors in
the `mc` correlator; by default, `mc_corr_eps=1e-10`.
Returns
-------
corr_mat : array
An 2-dimensional array (matrix) of correlation values for the times
specified by `tlist` (first index) and `taulist` (second index). If
`tlist` is `None`, then a 1-dimensional array of correlation values
is returned instead.
References
----------
See, Gardiner, Quantum Noise, Section 5.2.
"""
warn("correlation_4op_2t() now legacy, please use correlation_3op_2t()",
FutureWarning)
warn("the reverse argument has been removed as it did not contain any" +
"new physical information", DeprecationWarning)
if debug:
print(inspect.stack()[0][3])
return correlation_3op_2t(H, state0, tlist, taulist, c_ops,
a_op, b_op * c_op, d_op,
solver=solver, args=args, options=options)
# spectrum
[docs]def spectrum_ss(H, wlist, c_ops, a_op, b_op):
"""
Calculate the spectrum of the correlation function
:math:`\lim_{t \\to \\infty} \left<A(t+\\tau)B(t)\\right>`,
i.e., the Fourier transform of the correlation function:
.. math::
S(\omega) = \int_{-\infty}^{\infty}
\lim_{t \\to \\infty} \left<A(t+\\tau)B(t)\\right>
e^{-i\omega\\tau} d\\tau.
using an eseries based solver Note: this spectrum is only defined for
stationary statistics (uses steady state rho0).
Parameters
----------
H : :class:`qutip.qobj`
system Hamiltonian.
wlist : array_like
list of frequencies for :math:`\\omega`.
c_ops : *list* of :class:`qutip.qobj`
list of collapse operators.
a_op : :class:`qutip.qobj`
operator A.
b_op : :class:`qutip.qobj`
operator B.
use_pinv : *bool*
If `True` use numpy's `pinv` method, otherwise use a generic solver.
Returns
-------
spectrum : array
An array with spectrum :math:`S(\omega)` for the frequencies
specified in `wlist`.
"""
warn("spectrum_ss() now legacy, please use spectrum()", FutureWarning)
return spectrum(H, wlist, c_ops, a_op, b_op, solver="es")
[docs]def spectrum_pi(H, wlist, c_ops, a_op, b_op, use_pinv=False):
"""
Calculate the spectrum of the correlation function
:math:`\lim_{t \\to \\infty} \left<A(t+\\tau)B(t)\\right>`,
i.e., the Fourier transform of the correlation function:
.. math::
S(\omega) = \int_{-\infty}^{\infty}
\lim_{t \\to \\infty} \left<A(t+\\tau)B(t)\\right>
e^{-i\omega\\tau} d\\tau.
using a psuedo-inverse method. Note: this spectrum is only defined for
stationary statistics (uses steady state rho0)
Parameters
----------
H : :class:`qutip.qobj`
system Hamiltonian.
wlist : array_like
list of frequencies for :math:`\\omega`.
c_ops : *list* of :class:`qutip.qobj`
list of collapse operators.
a_op : :class:`qutip.qobj`
operator A.
b_op : :class:`qutip.qobj`
operator B.
use_pinv : *bool*
If `True` use numpy's pinv method, otherwise use a generic solver.
Returns
-------
spectrum : array
An array with spectrum :math:`S(\omega)` for the frequencies
specified in `wlist`.
"""
warn("spectrum_pi() now legacy, please use spectrum()", FutureWarning)
return spectrum(H, wlist, c_ops, a_op, b_op,
solver="pi", use_pinv=use_pinv)
# -----------------------------------------------------------------------------
# PRIVATE SOLVER METHODS
# -----------------------------------------------------------------------------
# master 2t correlation solver
def _correlation_2t(H, state0, tlist, taulist, c_ops, a_op, b_op, c_op,
solver="me", args={}, options=Options()):
"""
Internal function for calling solvers in order to calculate the
three-operator two-time correlation function:
<A(t)B(t+tau)C(t)>
"""
# Note: the current form of the correlator is sufficient for all possible
# two-time correlations (incuding those with 2ops vs 3). Ex: to compute a
# correlation of the form <A(t+tau)B(t)>: a_op = identity, b_op = A,
# and c_op = B.
if debug:
print(inspect.stack()[0][3])
if min(tlist) != 0:
raise TypeError("tlist must be positive and contain the element 0.")
if min(taulist) != 0:
raise TypeError("taulist must be positive and contain the element 0.")
if config.tdname:
_cython_build_cleanup(config.tdname)
rhs_clear()
H, c_ops, args = _td_wrap_array_str(H, c_ops, args, tlist)
if solver == "me":
return _correlation_me_2t(H, state0, tlist, taulist,
c_ops, a_op, b_op, c_op,
args=args, options=options)
elif solver == "mc":
return _correlation_mc_2t(H, state0, tlist, taulist,
c_ops, a_op, b_op, c_op,
args=args, options=options)
elif solver == "es":
return _correlation_es_2t(H, state0, tlist, taulist,
c_ops, a_op, b_op, c_op)
else:
raise ValueError("Unrecognized choice of solver" +
"%s (use me, mc, or es)." % solver)
# master equation solvers
def _correlation_me_2t(H, state0, tlist, taulist, c_ops, a_op, b_op, c_op,
args={}, options=Options()):
"""
Internal function for calculating the three-operator two-time
correlation function:
<A(t)B(t+tau)C(t)>
using a master equation solver.
"""
# the solvers only work for positive time differences and the correlators
# require positive tau
if state0 is None:
rho0 = steadystate(H, c_ops)
tlist = [0]
elif isket(state0):
rho0 = ket2dm(state0)
else:
rho0 = state0
if debug:
print(inspect.stack()[0][3])
rho_t = mesolve(H, rho0, tlist, c_ops, [],
args=args, options=options).states
corr_mat = np.zeros([np.size(tlist), np.size(taulist)], dtype=complex)
H_shifted, c_ops_shifted, _args = _transform_L_t_shift(H, c_ops, args)
if config.tdname:
_cython_build_cleanup(config.tdname)
rhs_clear()
for t_idx, rho in enumerate(rho_t):
if not isinstance(H, Qobj):
_args["_t0"] = tlist[t_idx]
corr_mat[t_idx, :] = mesolve(
H_shifted, c_op * rho * a_op, taulist, c_ops_shifted,
[b_op], args=_args, options=options
).expect[0]
if t_idx == 1:
options.rhs_reuse = True
if config.tdname:
_cython_build_cleanup(config.tdname)
rhs_clear()
return corr_mat
# exponential series solvers
def _correlation_es_2t(H, state0, tlist, taulist, c_ops, a_op, b_op, c_op):
"""
Internal function for calculating the three-operator two-time
correlation function:
<A(t)B(t+tau)C(t)>
using an exponential series solver.
"""
# the solvers only work for positive time differences and the correlators
# require positive tau
if state0 is None:
rho0 = steadystate(H, c_ops)
tlist = [0]
elif isket(state0):
rho0 = ket2dm(state0)
else:
rho0 = state0
if debug:
print(inspect.stack()[0][3])
# contruct the Liouvillian
L = liouvillian(H, c_ops)
corr_mat = np.zeros([np.size(tlist), np.size(taulist)], dtype=complex)
solES_t = ode2es(L, rho0)
# evaluate the correlation function
for t_idx in range(len(tlist)):
rho_t = esval(solES_t, [tlist[t_idx]])
solES_tau = ode2es(L, c_op * rho_t * a_op)
corr_mat[t_idx, :] = esval(expect(b_op, solES_tau), taulist)
return corr_mat
def _spectrum_es(H, wlist, c_ops, a_op, b_op):
"""
Internal function for calculating the spectrum of the correlation function
:math:`\left<A(\\tau)B(0)\\right>`.
"""
if debug:
print(inspect.stack()[0][3])
# construct the Liouvillian
L = liouvillian(H, c_ops)
# find the steady state density matrix and a_op and b_op expecation values
rho0 = steadystate(L)
a_op_ss = expect(a_op, rho0)
b_op_ss = expect(b_op, rho0)
# eseries solution for (b * rho0)(t)
es = ode2es(L, b_op * rho0)
# correlation
corr_es = expect(a_op, es)
# covariance
cov_es = corr_es - a_op_ss * b_op_ss
# tidy up covariance (to combine, e.g., zero-frequency components that cancel)
cov_es.tidyup()
# spectrum
spectrum = esspec(cov_es, wlist)
return spectrum
# Monte Carlo solvers
def _correlation_mc_2t(H, state0, tlist, taulist, c_ops, a_op, b_op, c_op,
args={}, options=Options()):
"""
Internal function for calculating the three-operator two-time
correlation function:
<A(t)B(t+tau)C(t)>
using a Monte Carlo solver.
"""
if not c_ops:
raise TypeError("If no collapse operators are required, use the `me`" +
"or `es` solvers")
# the solvers only work for positive time differences and the correlators
# require positive tau
if state0 is None:
raise NotImplementedError("steady state not implemented for " +
"mc solver, please use `es` or `me`")
elif not isket(state0):
raise TypeError("state0 must be a state vector.")
psi0 = state0
if debug:
print(inspect.stack()[0][3])
psi_t_mat = mcsolve(
H, psi0, tlist, c_ops, [],
args=args, ntraj=options.ntraj[0], options=options, progress_bar=None
).states
corr_mat = np.zeros([np.size(tlist), np.size(taulist)], dtype=complex)
H_shifted, c_ops_shifted, _args = _transform_L_t_shift(H, c_ops, args)
if config.tdname:
_cython_build_cleanup(config.tdname)
rhs_clear()
# calculation of <A(t)B(t+tau)C(t)> from only knowledge of psi0 requires
# averaging over both t and tau
for t_idx in range(np.size(tlist)):
if not isinstance(H, Qobj):
_args["_t0"] = tlist[t_idx]
for trial_idx in range(options.ntraj[0]):
if isinstance(a_op, Qobj) and isinstance(c_op, Qobj):
if a_op.dag() == c_op:
# A shortcut here, requires only 1/4 the trials
chi_0 = (options.mc_corr_eps + c_op) * \
psi_t_mat[trial_idx, t_idx]
# evolve these states and calculate expectation value of B
c_tau = chi_0.norm()**2 * mcsolve(
H_shifted, chi_0/chi_0.norm(), taulist, c_ops_shifted,
[b_op],
args=_args, ntraj=options.ntraj[1], options=options,
progress_bar=None
).expect[0]
# final correlation vector computed by combining the
# averages
corr_mat[t_idx, :] += c_tau/options.ntraj[1]
else:
# otherwise, need four trial wavefunctions
# (Ad+C)*psi_t, (Ad+iC)*psi_t, (Ad-C)*psi_t, (Ad-iC)*psi_t
if isinstance(a_op, Qobj):
a_op_dag = a_op.dag()
else:
# assume this is a number, ex. i.e. a_op = 1
# if this is not correct, the over-loaded addition
# operation will raise errors
a_op_dag = a_op
chi_0 = [(options.mc_corr_eps + a_op_dag +
np.exp(1j*x*np.pi/2)*c_op) *
psi_t_mat[trial_idx, t_idx]
for x in range(4)]
# evolve these states and calculate expectation value of B
c_tau = [
chi.norm()**2 * mcsolve(
H_shifted, chi/chi.norm(), taulist, c_ops_shifted,
[b_op],
args=_args, ntraj=options.ntraj[1], options=options,
progress_bar=None
).expect[0]
for chi in chi_0
]
# final correlation vector computed by combining the averages
corr_mat_add = np.asarray(
1.0 / (4*options.ntraj[0]) *
(c_tau[0] - c_tau[2] - 1j*c_tau[1] + 1j*c_tau[3]),
dtype=corr_mat.dtype
)
corr_mat[t_idx, :] += corr_mat_add
if t_idx == 1:
options.rhs_reuse = True
if config.tdname:
_cython_build_cleanup(config.tdname)
rhs_clear()
return corr_mat
# pseudo-inverse solvers
def _spectrum_pi(H, wlist, c_ops, a_op, b_op, use_pinv=False):
"""
Internal function for calculating the spectrum of the correlation function
:math:`\left<A(\\tau)B(0)\\right>`.
"""
L = H if issuper(H) else liouvillian(H, c_ops)
tr_mat = tensor([qeye(n) for n in L.dims[0][0]])
N = np.prod(L.dims[0][0])
A = L.full()
b = spre(b_op).full()
a = spre(a_op).full()
tr_vec = np.transpose(mat2vec(tr_mat.full()))
rho_ss = steadystate(L)
rho = np.transpose(mat2vec(rho_ss.full()))
I = np.identity(N * N)
P = np.kron(np.transpose(rho), tr_vec)
Q = I - P
spectrum = np.zeros(len(wlist))
for idx, w in enumerate(wlist):
if use_pinv:
MMR = np.linalg.pinv(-1.0j * w * I + A)
else:
MMR = np.dot(Q, np.linalg.solve(-1.0j * w * I + A, Q))
s = np.dot(tr_vec,
np.dot(a, np.dot(MMR, np.dot(b, np.transpose(rho)))))
spectrum[idx] = -2 * np.real(s[0, 0])
return spectrum
# auxiliary
def _transform_L_t_shift(H, c_ops, args={}):
"""
Time shift the Hamiltonian with private time-shift variable _t0
"""
# while this list doesn't seem exhaustive, mesolve has already been called
# and has hence called _td_format_check from qutip.rhs_generate. important
# to keep in mind is that mesolve already requires the types of
# time-dependence to be the same for the hamiltonian as for the collapse
# operators.
if isinstance(H, Qobj):
# constant hamiltonian
H_shifted = H # not shifted!
c_ops_is_td = False
if isinstance(c_ops, list):
for i in range(len(c_ops)):
# test is collapse operators are time-dependent
if isinstance(c_ops[i], list):
c_ops_is_td = True
if not c_ops_is_td:
# constant collapse operators
c_ops_shifted = c_ops # not shifted!
if isinstance(H, Qobj) and not c_ops_is_td:
# constant hamiltonian and collapse operators
_args = args # not shifted!
if isinstance(H, types.FunctionType):
# function-callback based time-dependence
if isinstance(args, dict) or args is None:
if args is None:
_args = {"_t0": 0}
else:
_args = args.copy()
_args["_t0"] = 0
H_shifted = lambda t, args_i: H(t+args_i["_t0"], args_i)
else:
raise TypeError("If using function-callback based Hamiltonian" +
"time-dependence, args must be a dictionary")
if isinstance(H, list) or c_ops_is_td:
# string/function-list based time-dependence
if args is None:
_args = {"_t0": 0}
elif isinstance(args, dict):
_args = args.copy()
_args["_t0"] = 0
else:
_args = {"_user_args": args, "_t0": 0}
if isinstance(H, list):
# hamiltonian is time-dependent
H_shifted = []
for i in range(len(H)):
if isinstance(H[i], list):
# modify Hamiltonian time dependence in accordance with the
# quantum regression theorem
if isinstance(args, dict) or args is None:
if isinstance(H[i][1], types.FunctionType):
# function-list based time-dependence
fn = lambda t, args_i: \
H[i][1](t + args_i["_t0"], args_i)
else:
# string-list based time-dependence
# Again, note: _td_format_check already raises
# errors formixed td formatting
fn = sub("(?<=[^0-9a-zA-Z_])t(?=[^0-9a-zA-Z_])",
"(t+_t0)", H[i][1])
else:
if isinstance(H[i][1], types.FunctionType):
# function-list based time-dependence
fn = lambda t, args_i: \
H[i][1](t + args_i["_t0"],
args_i["_user_args"])
else:
raise TypeError("If using string-list based" +
"Hamiltonian time-dependence, " +
"args must be a dictionary")
H_shifted.append([H[i][0], fn])
else:
H_shifted.append(H[i])
if c_ops_is_td:
# collapse operators are time-dependent
c_ops_shifted = []
for i in range(len(c_ops)):
if isinstance(c_ops[i], list):
# modify collapse operators time dependence in accordance
# with the quantum regression theorem
if isinstance(args, dict) or args is None:
if isinstance(c_ops[i][1], types.FunctionType):
# function-list based time-dependence
fn = lambda t, args_i: \
c_ops[i][1](t + args_i["_t0"], args_i)
else:
# string-list based time-dependence
# Again, note: _td_format_check already raises
# errors formixed td formatting
fn = sub("(?<=[^0-9a-zA-Z_])t(?=[^0-9a-zA-Z_])",
"(t+_t0)", c_ops[i][1])
else:
if isinstance(H[i][1], types.FunctionType):
# function-list based time-dependence
fn = lambda t, args_i: \
c_ops[i][1](t + args_i["_t0"],
args_i["_user_args"])
else:
raise TypeError("If using string-list based" +
"collapse operator" +
"time-dependence, " +
"args must be a dictionary")
c_ops_shifted.append([c_ops[i][0], fn])
else:
c_ops_shifted.append(c_ops[i])
return H_shifted, c_ops_shifted, _args


Write a short paragraph about yourself or some placeholder text.
A second short paragraph about yourself or some placeholder text.
| Books | Movies | Games |
|---|---|---|
| Data Science From Scratch | Molly's Game | Kaggle |
| The Name of the Wind | The Avengers | The Last of Us |
| The Girl With All the Gifts | The Matrix | Dragon Age: Origins |


Level 999
Try to catch X emojis in Y seconds.
Time's Up!
You catched 16 emoticons, and you had to catch 40 at least to complete this level.
Game Paused!
You catched 16 of the 40 emoticons you have to catch for this level.
You Won!
You catched all the 30 emoticons!
Now try to catch 40 emoticons.


Github limits requests to 60 per hour for unauthenticated requests. The extension caches all requests to prevent unnecessary API calls. The cache expires in one week which means you won't be able to see latest information about neither the user nor the repository. Although it seems long, it should be fine for most cases. If you want to go beyond the limit (5000 requests/hour) then you will need to create an Personal API Access Token from https://github.com/settings/applications and use the token below(Access token not storing elsewhere from your browser). In this case, cache won't be effective.


OUTB
Section: Linux Programmer's Manual (2)Updated: 1995-11-29
Index Return to Main Contents
NAME
outb, outw, outl, outsb, outsw, outsl, inb, inw, inl, insb, insw, insl, outb_p, outw_p, outl_p, inb_p, inw_p, inl_p - port I/ODESCRIPTION
This family of functions is used to do low-level port input and output. The out* functions do port output, the in* functions do port input; the b-suffix functions are byte-width and the w-suffix functions word-width; the _p-suffix functions pause until the I/O completes.They are primarily designed for internal kernel use, but can be used from user space.
You compile with -O or -O2 or similar. The functions are defined as inline macros, and will not be substituted in without optimization enabled, causing unresolved references at link time.
You use ioperm(2) or alternatively iopl(2) to tell the kernel to allow the user space application to access the I/O ports in question. Failure to do this will cause the application to receive a segmentation fault.
CONFORMING TO
outb() and friends are hardware-specific. The value argument is passed first and the port argument is passed second, which is the opposite order from most DOS implementations.SEE ALSO
ioperm(2), iopl(2)COLOPHON
This page is part of release 3.22 of the Linux man-pages project. A description of the project, and information about reporting bugs, can be found at http://www.kernel.org/doc/man-pages/.
Index
This document was created by man2html, using the manual pages.
Time: 05:33:04 GMT, December 24, 2015