Your Products
Set up frequently shipped products to make your life easier when filling out commercial invoices.
You can define any number of products to the right, and don’t worry, if you forgot to add one, we will automatically add it for you when you fill out a commercial invoice.
Products
| Qty | Name | Country | Unit Price | HS Code | Description |
|---|---|---|---|---|---|
| 1 | Name 1 | India | 10 | HS1245 | Test description |
| 2 | Name 2 | India | 20 | HS1245 | Test description 2 |
| 8 | Name 3 | India | 50 | HS1245 | Test description 3 |
| 1 | Beautify | India | 10 | HS1245 | Test description |
| 10 | Shipping | India | 100 | HS1245 | Test description |


If you are reading this, it is because your browser does not support the audio element.
Tap Beat App
Continue


| Param | Type | Details | Required | Default |
|---|---|---|---|---|
| scope | Scope | The scope the AngularMeteorCollection will be bound to |
Yes | |
| model | String | The name of the scope's model variable that the AngularMeteorCollection will be bound to |
Yes | |
| autoClientSave | Boolean | By default, changes in the scope's model will not automatically update the Meteor collection. However if set to true, changes in the client will be automatically propagated back to the collection. A deep watch is created when this is set to true, which will degrade performance |
No | False |
| publisher | Boolean/String | By default, bind method will not automatically subscribe to the collection. However if set to true, bind will call the $meteorSubscribe service on the current collection. You can also set publisher to a string and then bind will call Meteor publish with that string as the publish method's name. * Please note that if you want to pass a parameter to the publish method you should use the $meteorSubscribe service because adding the parameter in $collection.bind is not supported. |
No | False |
| paginate | Boolean | By default, bind method will not automatically add support to paginate the collection. However if set to true, the bind method will also add pagination functionality to the scope |
No | False |
| promise | A promise that holds the scope variable we binded to. If we used the 'Subscribe' parameter the promise will be resolved after the subscription has been successful, if not the promise is being resolved immediately.
|


It's a whole new way to create.
Available now.
Students, teachers, and schools |
More |
Learn how Adobe helps students,
teachers, and schools prepare for success and stand out.
Students
›
K–12
schools ›
Higher
ed institutions ›
Solutions |
More |
See how Adobe can help your company.
Creative
tools for companies ›
Digital
publishing and media ›
Digital
marketing and analytics ›


UVM provides other functionality at the package scope including methods, enums, defines, and classes. Some of these are targeted towards specific aspects of the functionality described in the UVM standard, and others are useful across multiple aspects.
| Global Functionality | |
| UVM provides other functionality at the package scope including methods, enums, defines, and classes. |


About the Creators and the Data
* AMT Software by Florian Thiery, Martin Unold (i3mainz).* Data by Florian Thiery and Dr. Allard Mees (RGZM).
show geometry concepts
show edges


By:Team T13-5
Since: Sept 2018
#Licence: MIT
- 1. Introduction
- 2. Quick Start
- 3. Features
- 3.1. Viewing help :
help
- 3.2. Adding a workout:
add
- 3.3. Listing all workouts :
list
- 3.4. Editing a workout :
edit
- 3.5. Locating workouts by name:
find
- 3.6. Deleting a workout :
delete
- 3.7. Selecting a workout :
select
- 3.8. Listing entered commands :
history
- 3.9. Profiling entered commands :
profile
- 3.10. Recommending a workout :
recommend
- 3.11. Undoing previous command :
undo
- 3.12. Redoing the previously undone command :
redo
- 3.13. Clearing all entries :
clear
- 3.14. Exiting the program :
exit
- 3.15. Saving the data
- 3.1. Viewing help :
- 4. FAQ
- 5. Command Summary
1. Introduction
WorkoutBook is for those who prefer to use a desktop app for managing workouts. More importantly, WorkoutBook is optimized for those who prefer to work with a Command Line Interface (CLI) while still having the benefits of a Graphical User Interface (GUI).
2. Quick Start
-
Type the command in the command box and press Enter to execute it.
e.g. typinghelp
and pressing Enter will open the help window. -
Some example commands you can try:
-
list
: lists all workouts -
add
add name/commando workout type/strength duration/20m difficulty/advanced equipment/dumbbell, bench muscle/bicep, tricep calories/150 instruction/set 1: bicep curl reps: 4-6 set 2: tricep extension reps: 4-6 tag/heavy
: adds a Workout namedcommando workout
to the WorkoutBook. -
delete
3
: deletes the 3rd workout shown in the current list -
exit
: exits the app
-
-
Refer to Section 3, “Features” for details of each command.
3. Features
Command Format
-
Words in
UPPER_CASE
are the parameters to be supplied by the user e.g. inadd name/NAME
,NAME
is a parameter which can be used asadd name/commando workout
. -
Items in square brackets are optional e.g
name/NAME [tag/TAG]
can be used asname/commando workout tag/strength
or asname/commando workout
. -
Items with
…
after them can be used multiple times including zero times e.g.[tag/TAG]…
can be used as
(i.e. 0 times),tag/strength
,tag/strength tag/fast-paced
etc. -
Parameters can be in any order e.g. if the command specifies
name/NAME type/TYPE
,type/TYPE name/NAME
is also acceptable.
3.1. Viewing help : help
Format: help
3.2. Adding a workout: add
Adds a workout to the workout book
Format: add name/NAME [type/TYPE] [duration/DURATION] [difficulty/DIFFICULTY] [equipment/EQUIPMENT] [muscle/MUSCLE] [calories/CALORIES] [instruction/INSTRUCTION] [tag/TAG]…
| A workout can have any number of tags (including 0) |
Examples:
-
add name/commando workout type/strength, cardio duration/20m difficulty/advanced equipment/dumbbell, bench muscle/bicep, tricep calories/150 instruction/set 1: bicep curl reps: 4-6 set 2: tricep extension reps: 4-6 tag/heavy
3.3. Listing all workouts : list
Shows a list of all workouts in the workout book.
Format: list
3.4. Editing a workout : edit
Edits an existing workout in the workout book.
Format: edit INDEX name/NAME [type/TYPE] [duration/DURATION] [difficulty/DIFFICULTY] [equipment/EQUIPMENT] [muscle/MUSCLE] [calories/CALORIES] [instruction/INSTRUCTION] [tag/TAG]…
Examples:
-
edit 1 type/strength duration/20m
Edits the type and duration of the 1st workout to bestrength
and20m
respectively. -
edit 2 name/Arnold’s workout tag/
Edits the name of the 2nd workout to beArnold’s workout
and clears all existing tags.
3.5. Locating workouts by name: find
Finds workouts whose names contain any of the given keywords.
Format: find KEYWORD [MORE_KEYWORDS]
Examples:
-
find commando
Returnscommand workout
-
find commando arnold’s
Returns any workout having namescommando
orarnold’s
3.6. Deleting a workout : delete
Deletes the specified workout from the workout book.
Format: delete INDEX
Examples:
-
list
delete 2
Deletes the 2nd workout in the workout book. -
find commando
delete 1
Deletes the 1st workout in the results of thefind
command.
3.7. Selecting a workout : select
Selects the workout identified by the index number used in the displayed workout list.
Format: select INDEX
Examples:
-
list
select 2
Selects the 2nd workout in the workout book. -
find commando
select 1
Selects the 1st workout in the results of thefind
command.
3.8. Listing entered commands : history
Lists all the commands that you have entered in reverse chronological order.
Format: history
|
Pressing the ↑ and ↓ arrows will display the previous and next input respectively in the command box. |
3.9. Profiling user's profile : profile
Shows the user profile
Format: profile
3.10. Recommending a workout : recommend
Recommend a workout from the existing workouts identified by the PARAMETER
.
Format: recommend r/[PARAMETER]
Examples:
-
recommend r/beginner
Recommends a beginner workout. -
recommend r/strength
Recommends a strength workout.
3.10. Undoing previous command : undo
Restores the workout book to the state before the previous undoable command was executed.
Format: undo
|
Undoable commands: those commands that modify the workout book’s content ( |
Examples:
-
delete 1
list
undo
(reverses thedelete 1
command) -
select 1
list
undo
Theundo
command fails as there are no undoable commands executed previously. -
delete 1
clear
undo
(reverses theclear
command)
undo
(reverses thedelete 1
command)
3.11. Redoing the previously undone command : redo
Reverses the most recent undo
command.
Format: redo
Examples:
-
delete 1
undo
(reverses thedelete 1
command)
redo
(reapplies thedelete 1
command) -
delete 1
redo
Theredo
command fails as there are noundo
commands executed previously. -
delete 1
clear
undo
(reverses theclear
command)
undo
(reverses thedelete 1
command)
redo
(reapplies thedelete 1
command)
redo
(reapplies theclear
command)
3.12. Clearing all entries : clear
Clears all entries from the workout book.
Format: clear
3.13. Exiting the program : exit
Exits the program.
Format: exit
3.14. Saving the data
workout book data are saved in the hard disk automatically after any command that changes the data.
There is no need to save manually.
3.14. Encrypting data files [coming in v2.0]
{explain how the user can enable/disable data encryption}
5. Command Summary
-
Add
add name/NAME [type/TYPE] [duration/DURATION] [difficulty/DIFFICULTY] [equipment/EQUIPMENT] [muscle/MUSCLE] [calories/CALORIES] [instruction/INSTRUCTION] [tag/TAG]…
e.g.add name/commando workout type/strength, cardio duration/20m difficulty/advanced equipment/dumbbell, bench muscle/bicep, tricep calories/150 instruction/set 1: bicep curl reps: 4-6 set 2: tricep extension reps: 4-6 tag/heavy
-
Clear :
clear
-
Delete :
delete INDEX
e.g.delete 3
-
Edit :
edit INDEX [name/NAME] [type/TYPE] [duration/DURATION] [difficulty/DIFFICULTY] [equipment/EQUIPMENT] [muscle/MUSCLE] [calories/CALORIES] [instruction/INSTRUCTION] [tag/TAG]…
e.g.edit 1 type/light duration/25m
-
Find :
find KEYWORD [MORE_KEYWORDS]
e.g.find bench
-
List :
list
-
Help :
help
-
Select :
select INDEX
e.g.select 2
-
History :
history
-
Profile :
profile
-
Undo :
undo
-
Redo :
redo


(). infection virus samples Australian Queensland infections antibodies IgM {border-style px;} study #ffffff;} viruses arboviruses blood flaviviruses neutralising Australia RRV annual clinical neutralised rate MVEV alphaviruses patients prevalence UFI antibody cells number However, KUNV Med. donors rates sera tests BFV River disease neglected ./j.-..tb.x Aust.–. Research cause caused human humans infected .%, Health, Murray North Ross Valley activity i.e., observed performed px; reported seroprevalence {font-family (.%) Australia, Government University arbovirus collected commercial diagnostic encephalitis febrile font-size line plasma residents significant single transmission (Table Biol. Central Department EHV, Flaviviruses RRV, STRV Sci.–. age arthropod-borne contained cross-reactive data detect determined double; fever neutralisation numbers possible sample study. using < (.%), ./icb.. BFV, Blood DohertyR. Exp. KOKV, KUNV, Kunjin added assay assumed available border-color border-width cases considered determine diagnosed diagnosis enhancement flavivirus greater highest identified including known low presence public serological serum small solid; south subject testing undifferentiated {font-style {font-weight (.% (Australian (Figure (Gyawali ./-()- ALFV ALFV, Aaskov Australia. Barmah Cross DENV Doherty EHV Ethics Far Health Human Hyg.–. IFA IgM-reactive KOKV Line New Notifiable Plasma QLDAustralia[], Queensland, Red Soc. South Student’s Studies TABLE Trop. Virol.–. agent alphavirus anti-viral associated bold changes collection courier; current donors. em; employed epidemic extent health hosts immunofluorescence obtained plaque plaques possibility potential pt;} reflect required results routine significantly slide tested unknown value values virus;


Version 1.9 notes and API changes¶
This page reflects API changes from NetworkX 1.8 to NetworkX 1.9.
Please send comments and questions to the networkx-discuss mailing list: <http://groups.google.com/group/networkx-discuss>.
Flow package¶
The flow package (networkx.algorithms.flow
) is completely rewritten
with backward incompatible changes. It introduces a new interface to flow
algorithms. Existing code that uses the flow package will not work unmodified
with NetworkX 1.9.
Main changes¶
- We added two new maximum flow algorithms (
preflow_push
andshortest_augmenting_path
) and rewrote the Edmonds–Karp algorithm inflow_fulkerson
which is now inedmonds_karp
. @ysitu contributed implementations of all new maximum flow algorithms. The legacy Edmonds–Karp algorithm implementation inford_fulkerson
is still available but will be removed in the next release. - All maximum flow algorithm implementations (including the legacy
ford_fulkerson
) output now a residual network (i.e., aDiGraph
) after computing the maximum flow. Seemaximum_flow
documentation for the details on the conventions that NetworkX uses for defining a residual network. - We removed the old
max_flow
andmin_cut
functions. The main entry points to flow algorithms are now the functionsmaximum_flow
,maximum_flow_value
,minimum_cut
andminimum_cut_value
, which have new parameters that control maximum flow computation:flow_func
for specifying the algorithm that will do the actual computation (it accepts a function as argument that implements a maximum flow algorithm),cutoff
for suggesting a maximum flow value at which the algorithm stops,value_only
for stopping the computation as soon as we have the value of the flow, andresidual
that accepts as argument a residual network to be reused in repeated maximum flow computation. - All flow algorithms are required to accept arguments for these parameters
but may selectively ignored the inapplicable ones. For instance,
preflow_push
algorithm can stop after the preflow phase without computing a maximum flow if we only need the flow value, but bothedmonds_karp
andshortest_augmenting_path
always compute a maximum flow to obtain the flow value. - The new function
minimum_cut
returns the cut value and a node partition that defines the minimum cut. The functionminimum_cut_value
returns only the value of the cut, which is what the removedmin_cut
function used to return before 1.9. - The functions that implement flow algorithms (i.e.,
preflow_push
,edmonds_karp
,shortest_augmenting_path
andford_fulkerson
) are not imported to the base NetworkX namespace. You have to explicitly import them from the flow package:
>>> from networkx.algorithms.flow import (ford_fulkerson, preflow_push,
... edmonds_karp, shortest_augmenting_path)
- We also added a capacity-scaling minimum cost flow algorithm:
capacity_scaling
. It supportsMultiDiGraph
and disconnected networks.
Examples¶
Below are some small examples illustrating how to obtain the same output than in NetworkX 1.8.1 using the new interface to flow algorithms introduced in 1.9:
>>> import networkx as nx
>>> G = nx.icosahedral_graph()
>>> nx.set_edge_attributes(G, 'capacity', 1)
With NetworkX 1.8:
>>> flow_value = nx.max_flow(G, 0, 6)
>>> cut_value = nx.min_cut(G, 0, 6)
>>> flow_value == cut_value
True
>>> flow_value, flow_dict = nx.ford_fulkerson(G, 0, 6)
With NetworkX 1.9:
>>> from networkx.algorithms.flow import (ford_fulkerson, preflow_push,
... edmonds_karp, shortest_augmenting_path)
>>> flow_value = nx.maximum_flow_value(G, 0, 6)
>>> cut_value = nx.minimum_cut_value(G, 0, 6)
>>> flow_value == cut_value
True
>>> # Legacy: this returns the exact same output than ford_fulkerson in 1.8.1
>>> flow_value, flow_dict = nx.maximum_flow(G, 0, 6, flow_func=ford_fulkerson)
>>> # We strongly recommend to use the new algorithms:
>>> flow_value, flow_dict = nx.maximum_flow(G, 0, 6)
>>> # If no flow_func is passed as argument, the default flow_func
>>> # (preflow-push) is used. Therefore this is the same than:
>>> flow_value, flow_dict = nx.maximum_flow(G, 0, 6, flow_func=preflow_push)
>>> # You can also use alternative maximum flow algorithms:
>>> flow_value, flow_dict = nx.maximum_flow(G, 0, 6, flow_func=shortest_augmenting_path)
>>> flow_value, flow_dict = nx.maximum_flow(G, 0, 6, flow_func=edmonds_karp)
Connectivity package¶
The flow-based connecitivity and cut algorithms from the connectivity
package (networkx.algorithms.connectivity
) are adapted to take
advantage of the new interface to flow algorithms. As a result, flow-based
connectivity algorithms are up to 10x faster than in NetworkX 1.8 for some
problems, such as sparse networks with highly skewed degree distributions.
A few backwards incompatible changes were introduced.
- The functions for local connectivity and cuts accept now
arguments for the new parameters defined for the flow interface:
flow_func
for defining the algorithm that will perform the underlying maximum flow computations,residual
that accepts as argument a residual network to be reused in repeated maximum flow computations, andcutoff
for defining a maximum flow value at which the underlying maximum flow algorithm stops. The big speed improvement with respect to 1.8 comes mainly from the reuse of the residual network and the use ofcutoff
. - We removed the flow-based local connectivity and cut functions from
the base namespace. Now they have to be explicitly imported from the
connectivity package. The main entry point to flow-based connectivity
and cut functions are the functions
edge_connectivity
,node_connectivity
,minimum_edge_cut
, andminimum_node_cut
. All these functions accept a couple of nodes as optional arguments for computing local connectivity and cuts. - We improved the auxiliary network for connectivity functions: The node
mapping dict needed for node connectivity and minimum node cuts is now a
graph attribute of the auxiliary network. Thus we removed the
mapping
parameter from the local versions of connectivity and cut functions. We also changed the parameter name for the auxuliary digraph fromaux_digraph
toauxiliary
. - We changed the name of the function
all_pairs_node_connectiviy_matrix
toall_pairs_node_connectivity
. This function now returns a dictionary instead of a NumPy 2D array. We added a new parameternbunch
for computing node connectivity only among pairs of nodes innbunch
. - A
stoer_wagner
function is added to the connectivity package for computing the weighted minimum cuts of undirected graphs using the Stoer–Wagner algorithm. This algorithm is not based on maximum flows. Several heap implementations are also added in the utility package (networkx.utils
) for use in this function.BinaryHeap
is recommended overPairingHeap
for Python implementations without optimized attribute accesses (e.g., CPython) despite a slower asymptotic running time. For Python implementations with optimized attribute accesses (e.g., PyPy),PairingHeap
provides better performance.
Other new functionalities¶
- A
disperson
function is added in the centrality package (networkx.algorithms.centrality
) for computing the dispersion of graphs. - A community package (
networkx.generators.community
) is added for generating community graphs. - An
is_semiconnected
function is added in the connectivity package (networkx.algorithms.connectivity
) for recognizing semiconnected graphs. - The
eulerian_circuit
function in the Euler package (networkx.algorithm.euler
) is changed to use a linear-time algorithm. - A
non_edges
function in added in the function package (networkx.functions
) for enumerating nonexistent edges between existing nodes of graphs. - The linear algebra package (
networkx.linalg
) is changed to use SciPy sparse matrices. - Functions
algebraic_connectivity
,fiedler_vector
andspectral_ordering
are added in the linear algebra package (networkx.linalg
) for computing the algebraic connectivity, Fiedler vectors and spectral orderings of undirected graphs. - A link prediction package (
networkx.algorithms.link_prediction
) is added to provide link prediction-related functionalities. - Write Support for the graph6 and sparse6 formats is added in the read/write
package (
networx.readwrite
). - A
goldberg_radzik
function is added in the shortest path package (networkx.algorithms.shortest_paths
) for computing shortest paths using the Goldberg–Radzik algorithm. - A tree package (
networkx.tree
) is added to provide tree recognition functionalities. - A context manager
reversed
is added in the utility package (networkx.utils
) for temporary in-place reversal of graphs.
Miscellaneous changes¶
- The functions in the components package
(
networkx.algorithms.components
) such asconnected_components
,connected_components_subgraph
now return generators instead of lists. To recover the earlier behavior, uselist(connected_components(G))
. - JSON helpers in the JSON graph package (
networkx.readwrite.json_graph
) are removed. Use functions from the standard library (e.g.,json.dumps
) instead. - Support for Python 3.1 is dropped. Basic support is added for Jython 2.7 and IronPython 2.7, although they remain not officially supported.
- Numerous reported issues are fixed.


Your greatest power is the power to be: to be more loving, courageous, joyous, friendly, sensitive, aware, forgiving, tolerant, humble, patient, helpful. To be a greater human being.


Can't dismiss the commandt file list
-
anonymous
Hi,
I'm a relative noob to VIM and commandt. I'm using VIM in the Mac OSX terminal.
Problem is very elementary - Esc is not exiting the commandt file list. Esc seems to function as expected elsewhere in VIM, so I'm a little confused why it is not functioning for commandt.
Any advice appreciated.
-
Greg Hurrell
If the
TERM
type is anything like xterm, you'll probably need to make a special mapping to make the ESC key work. For an example, see this post.
Reply
This topic is now closed.


"blog noise?!" .03% of the web is changing Google
Here. Apparently, 0.03% of the web is made up of blogs, but that's still enough to change Google's basic assumptions:
"They presumed that technicians at USC would link to the best papers from MIT, to the best local sites from a land trust or a river study - rather than a clique, a small group of people writing about each other constantly. They obviously bump the rankings system in a way for which it wasn't prepared."
Because of this, Google is likely to set up a "Blog" tab and take blog results out of the main searches. I'm on the fence as to whether the latter is a good thing, but it's nice to know that something grassroots like blogs can still change the world.
[radio.weblogs.com/0001011]


Jupyter Notebooks don't currently support libraries to plot historical data, but we are working on adding the functionality. Until the functionality is added, use Python to plot custom indicators.
Follow these steps to plot the indicator values:
plot
method.custom_dataframe.plot()
plt.show()


Reports references to non-constant private members of an outer class from inside an inner class or to members of an inner class from a containing class.
An inner class and its containing class are compiled to separate class files. The virtual machine normally prohibits access from a class to private fields and methods of another class. To enable access from an inner class to private members of a containing class or the other way around javac and other compilers create package private synthetic accessor methods. Less use of memory and greater performance may be achieved by making the member package local, thus allowing direct access without the creation of synthetic accessor methods.


{%extends 'insta/base.html'%} {% block content %}
Instagram clone is a clone of real Instagram app. It is a image sharing and social media service designed to enable saving and discovery of information on the World Wide Web using images and videos with added Information.
By Kiptoo Kennedy


This package defines several extensions to the StAX API, more precisely for the {@link javax.xml.stream.XMLStreamReader} and {@link javax.xml.stream.XMLStreamWriter} classes. The reader or writer wishing to support the extension MAY implement the corresponding interface directly, but a consumer MUST use the property mechanism to get a reference to this extension interface, i.e. it MUST call {@link javax.xml.stream.XMLStreamReader#getProperty(String)} or {@link javax.xml.stream.XMLStreamWriter#getProperty(String)}. Each of the extension interfaces in this package defines a constant for the property name to use.
The rationale for this requirement is that a property based approach continues to work even if the
stream implementing the extension is accessed indirectly through a proxy implementing the
{@link javax.xml.stream.XMLStreamReader} or {@link javax.xml.stream.XMLStreamWriter} interface but unaware
of the extensions defined in this package. Note that this assumes that the proxy correctly delegates calls to the
getProperty
methods.
The property returning the extension interface MUST be available regardless of the current state of the stream. In addition it is assumed to be immutable, i.e. its value MUST NOT not change during the lifetime of the {@link javax.xml.stream.XMLStreamReader} or {@link javax.xml.stream.XMLStreamWriter} implementation. For a consumer it is therefore sufficient to look up the extension once and to continue using the obtained reference during the entire lifetime of the stream.


Welcome to MuMind C: Find study buddies with similar interests Let's start exploring by shouting out a message from your university!


Ed Ayers (through Spring 2014)
President of the University of Richmond, Historian of U.S. History, and Director of the Valley of the Shadow project.
Michael Fox
Director of the Minnesota Historical Society (retired).
Alan Liu
Professor and Chair, Department of English, University of California, Santa Barbara and Director of the Research-oriented Social Networks (RoSE) project.
Susan Perdue
Director of Documents Compass, Virginia Foundation for the Humanities, and People of the Founding Era project.
Kenneth Price
Professor, Department of English and Co-director of Center for Digital Research in the Humanities, University of Nebraska, and Co-editor of the Walt Whitman Archive.
Michael Rush
Archivist with the Beinecke Rare Book & Manuscript Library, Yale University, and Co-chair of the SAA Standards Committee, Technical Subcommittee on Encoded Archival Description.
Anne Van Camp
Director of the Smithsonian Institution Archives.
Previous Board members
Jodi Allison-Bunnell is Program Manager at Northwest Digital Archives, Orbis Cascade Alliance.
Edward Gaynor is Head of Collection Development and Description at the Albert and Shirley Small Special Collections Library, University of Virginia .
Mary Lacy is a Manuscript Librarian, Manuscript Division, Library of Congress.
Michelle Light is Archivist and Acting Head of Special Collections and Archives, Libraries at the University of California, Irvine.
Jerry Simmons is an Archives Specialist for Data Standards at the National Archives and Records Administration, and member of the SAA Standards Committee, Technical Subcommittee on Encoded Archival Context.


Find \displaystyle\lim_{x \to PM\infty}\dfrac{NUM.text()}{DEN.text()}
.
fractionReduce( NUM.getCoefAndDegreeForTerm(0).coef, DEN.getCoefAndDegreeForTerm(0).coef )
fractionReduce( -NUM.getCoefAndDegreeForTerm(0).coef, DEN.getCoefAndDegreeForTerm(0).coef )
+\infty
-\infty
0
Look at the leading terms expr(NUM.expr()[1])
and expr(DEN.expr()[1])
.
Because they have the same degree DEG
, the limit is equal to the quotient of their coefficients.
\displaystyle\lim_{x \to PM\infty}\dfrac{NUM.text()}{DEN.text()} = fractionSimplification( NUM.coefs[DEG], DEN.coefs[DEG] )
Find \displaystyle\lim_{x \to PM\infty}\dfrac{NUM.text()}{DEN.text()}
.
0
fractionReduce( NUM.getCoefAndDegreeForTerm(0).coef, DEN.getCoefAndDegreeForTerm(0).coef )
fractionReduce( -NUM.getCoefAndDegreeForTerm(0).coef, DEN.getCoefAndDegreeForTerm(0).coef )
+\infty
-\infty
Look at the leading terms expr(NUM.expr()[1])
and expr(DEN.expr()[1])
.
Because the numerator's degree NUM.getCoefAndDegreeForTerm(0).degree
is less than the denominator's degree DEN.getCoefAndDegreeForTerm(0).degree
, the bottom term dominates as x
approaches PM\infty
.
Since the denominator grows faster than the numerator, the limit goes to 0
.
Find \displaystyle\lim_{x \to \infty}\dfrac{NUM.text()}{DEN.text()}
.
RIGHT_SIGN\infty
fractionReduce( NUM.getCoefAndDegreeForTerm(0).coef, DEN.getCoefAndDegreeForTerm(0).coef )
fractionReduce( -NUM.getCoefAndDegreeForTerm(0).coef, DEN.getCoefAndDegreeForTerm(0).coef )
WRONG_SIGN\infty
0
Look at the leading terms expr(NUM.expr()[1])
and expr(DEN.expr()[1])
.
As x \to \infty
, the numerator approaches NUM.getCoefAndDegreeForTerm(0).coef < 0 ? "-" : ""\infty
because the coefficient NUM.getCoefAndDegreeForTerm(0).coef
is NUM.getCoefAndDegreeForTerm(0).coef < 0 ? "negative" : "positive".
As x \to \infty
, the denominator NUM.getCoefAndDegreeForTerm(0).coef * DEN.getCoefAndDegreeForTerm(0).coef > 0 ? "also " : ""approaches DEN.getCoefAndDegreeForTerm(0).coef < 0 ? "-" : ""\infty
because the coefficient DEN.getCoefAndDegreeForTerm(0).coef
is DEN.getCoefAndDegreeForTerm(0).coef < 0 ? "negative" : "positive".
Because the numerator's degree NUM.getCoefAndDegreeForTerm(0).degree
is greater than the denominator's degree DEN.getCoefAndDegreeForTerm(0).degree
, the limit diverges.
The numerator and denominator have the same sign as x
gets large, so the limit is +\infty
.
The numerator and denominator have differing signs as x
gets large, so the limit is -\infty
.
Find \displaystyle\lim_{x \to K}\dfrac{A}{Bx + -K}
.
undefined
fractionReduce( A, K )
fractionReduce( A, -K )
+\infty
-\infty
0
Consider the behavior of the function as x \to K
from each direction.
As x
approaches K
from the left, Bx + -K
starts negative and increases as it approaches 0
, so \dfrac{A}{Bx + -K}
approaches -\infty
.
As x
approaches K
from the right, Bx + -K
starts positive and decreases as it approaches 0
, so \dfrac{A}{Bx + -K}
approaches +\infty
.
Since the left- and right-hand limits are not equal, the limit is not defined.
Find \displaystyle\lim_{x \to K}\dfrac{A}{(Bx + -K\smash{)}^2}
.
RIGHT_SIGN\infty
fractionReduce( A, K * K )
fractionReduce( A, -K * K )
WRONG_SIGN\infty
0
Consider the behavior of the function as x \to K
from each direction.
In either direction, (x + -K)^2
approaches 0
, so \dfrac{A}{(Bx + -K\smash{)}^2}
diverges.
Because (x + -K)^2
is always positive and A
is A > 0 ? "positive" : "negative", \dfrac{A}{(Bx + -K\smash{)}^2}
approaches RIGHT_SIGN\infty
.


|
I am trying to setup a monitor to tail a table in my Postgres DB. I have a TIMESTAMP column that I am specifying as the rising column. It does not seem to be pulling the data in. I can query the DB just fine with the exception that the timestamp is formatted in epoch. I have a directory monitor that is working just fine. Can someone please give me a few pointers on how to get my table monitor working? Thank you, j |
|
The timestamp being emitted in epoch format is actually intended behavior. Regarding your input not indexing your events: Can you please provide further information?
answered 19 Dec '12, 12:17
ziegfried ♦
With your help I was able to see what looks like a memory issue. But I have no idea what to do with it. The table I have is large and I just want to start data from now forward. 2012-12-19 15:27:16.031 monsch1:ERROR:Scheduler - Caught ExecutionException: java.util.concurrent.ExecutionException: java.lang.OutOfMemoryError: Java heap space java.util.concurrent.ExecutionException: java.lang.OutOfMemoryError: Java heap space 2012-12-19 15:27:16.031 dbx4409:INFO:ExecutionContext - Execution finished in duration=24530 ms
(19 Dec '12, 15:38)
jcrane
cat ./etc/apps/dbx/default/inputs.conf Copyright (C) 2005-2012 Splunk Inc. All Rights Reserved.JBridge Server script[script://$SPLUNK_HOME/etc/apps/dbx/bin/jbridge_server.py] index = _internal sourcetype = dbx_jbridge interval = 0 disabled = true passAuth = admin [script://$SPLUNK_HOMEetcappsdbxbinjbridge_server.py] index = _internal sourcetype = dbx_jbridge interval = 0 disabled = true passAuth = admin
(19 Dec '12, 15:46)
jcrane
cat ./etc/apps/dbx/local/inputs.conf [script://$SPLUNK_HOME/etc/apps/dbx/bin/jbridge_server.py] disabled = 0 [batch://$SPLUNK_HOME/var/spool/dbmon/*.dbmonevt] crcSalt = <source> disabled = 0 move_policy = sinkhole sourcetype = dbmon:spool [dbmon-tail://MyType/Events] output.format = kv output.timestamp = 0 table = events tail.rising.column = uploaded host = MyHost index = default interval = auto sourcetype = MyType disabled = 0
(19 Dec '12, 15:48)
jcrane
You can configure the input to fetch new data from now on by specifying
in the
(19 Dec '12, 15:56)
ziegfried ♦
(After you changed the file, a restart is necessary in order for DB Connect to pick up the changes)
(19 Dec '12, 15:57)
ziegfried ♦
This still did not solve the monitor issue. Maybe I don't need it. I seem to be able to save queries and put the results in a dashboard. Should I just ignore doing a monitor on the DB tables?
(19 Dec '12, 17:52)
jcrane
Forgot to mention I am not seeing any log issues for the monitor.
(19 Dec '12, 17:53)
jcrane
You might want to try the database monitor again with the latest version. There was a potential problem with the postgres JDBC driver that is now being taken care of.
(15 Jan, 20:03)
ziegfried ♦
I did try to upgrade and it didn't seem to help the monitor. Actually it seems the change made the errors coming back from the DB less clear in Splunk. That is not a big deal the logs in the DB show exactly what happened to the query but it was worth noting.
(12 Feb, 15:16)
jcrane
showing 5 of 9
show 4 more comments ▼
|


{% extends "app/layout.html" %} {% load staticfiles %} {% block content %}
Signing up gives you the opportunity to have an account, which is necessary to visit the website and upload documents. A valid phone number is necessary to open an account.
Wish to leave? Simply click this button, all your authentication data will be flushed


Dev Bootcamp Phase 0
Week 9
February 1, 2016
It's finally time to reflect on actually building a website. I've learned a lot from the process.
The Good
Making a website is NOT difficult. Even if you suck at html and css, even if you aren't good at design or don't know what you want to put on your site, you really can do it. Particularly if you know enough html / css to go online and grab existing templates (e.g., via Bootstrap). I was also surprised how generous github is with their free hosting. As long as you don't mind having their name in your url, there is no need to buy / hook up a domain name! All in all, getting this sucker online was very doable.
The Challenges
Making a site isn't all a walk in the park though. It is super easy to get caught up in the nitty gritty of your site and soon hours have gone by and all you've done is add one half-working interactive JS element. Connected to this, I don't think the resources available online to help you take your website from static to interactive are all that great ... I mostly spent my hours surfing on the web more confused and discouraged. Timeboxing is definitely important to help manage this. Also: asking for feedback (and not being afraid to show others your unfinished project).


Calories calculator
Age
Height
Weight
Gender
Set your Goal
You need to eat xxxxx calories per day to lose 5kg per week


How to verify your account
What do you mean? This must be easy right?
Verification for the legit server
Follow these three simple steps to get started playing {{ appName() }}'s legit server!
1
Download the Iteki patcher
Download the patcher to allow you to connect to Iteki here.
2
Run the newly created shortcut
Go to your Desktop to see the newly created `Iteki` shortcut. Run this shortcut and your osu! will be opened and connected to the Iteki server!
3
Login to your account
Login to your {{ appName() }} account and you should be done! Welcome to the community! Please also take the time to read the legit rules here.
Verification for the cheat server
Follow these three simple steps to get started playing {{ appName() }}'s cheat server!
1
Download the Iteki Cheat Client
Download the custom client to allow you to connect to Iteki's cheat server with pre-built cheats here.
2
Place the downloaded file into your osu! folder
You should notice you now have a new file called iteki-cheat.exe. Place this in your osu! folder and run it.
3


In homage to George Orwell's egg counting mania, I decided it would be an excellent idea to begin the new year by launching—to much fanfare, of course—Frank Key's Squirrel Count™. I can think of nothing that would excite readers quite as much as learning how many squirrels I have seen each day. So, to the sound of tooting horns and shrill whistle-blasts, with flags and banners flying, and perhaps some clowns cavorting upon a specially-built platform, here is the very first bulletin from Frank Key's Squirrel Count™ 2009.
01.01.09 Six squirrels, or possibly three squirrels each seen twice.


--- layout: default title: Query require: treetable datatables highcharts izitoast corpus script: query.js class: data query page wide ---


I recently learned about this trick for optimizing certain SQL queries, so I thought I'd share it in a blog post. It applies specifically to any query in which you have to retrieve some data from a table via two different routes. What do I mean by routes? Well if we think of our database as a large graph, where the nodes are the tables and the edges are the foreign key relationships between them, then having a "route" to certain data is just a path between two nodes. So having two different routes to get at the data you want might look something like this:
Normally this would be done using
JOIN
clauses. To imagine that let's create an example schema. Perhaps you work at a company which uses
a SQL database to manage its orders. Whenever a customer places an order it gets recorded within a table called orders
. In addition to tracking orders, perhaps your company wants to track which customers placed which orders by name. So we have another
table called customer
. Let's say that a group of customers can all place a single order together, and that one customer
can place many orders. As such, there must be a many-to-many relationship with a table between them, which we'll call
customer_order
.
CREATE TABLE orders(
order_id SERIAL PRIMARY KEY,
);
CREATE TABLE customer (
customer_id SERIAL PRIMARY KEY,
name VARCHAR
);
CREATE TABLE customer_order (
customer_id INTEGER NOT NULL,
order_id INTEGER NOT NULL,
CONSTRAINT fk_customer FOREIGN KEY(customer_id) REFERENCES customer(customer_id),
CONSTRAINT fk_order FOREIGN KEY(order_id) REFERENCES orders(order_id)
);
Now let's say that you're designing a feature for your system in which you need to search for all the orders that a customer has placed, and that you need to be able to search by the customer's name. It's pretty easy to implement this.

That's all well and good. But now let's imagine that you want to start grouping customers. It might be interesting to track
which company a customer belongs to, if they belong to any at all. So you add another table called company
with
a one-to-many relationship with customers, assuming each customer can only belong to one company. But here's the kicker...
let's say when someone places an order they can choose to either do it as an individual customer, or do it on behalf of
a company. If they choose the latter, then they don't have to supply any of their own individual customer information
because all of that information is already stored when the company "registered" in our system and assigned a few
"point of contact" customers to themselves ahead of time. This means that in order to continue accurately tracking which
customers are associated with orders, we need to link the company
and order
tables. Like the
relationship between customers and orders, this will also have a many-to-many relationship with an intermediary table called
company_order
. Let's see what our new schema looks like.
CREATE TABLE orders(
order_id SERIAL PRIMARY KEY,
);
CREATE TABLE company (
company_id SERIAL PRIMARY KEY,
)
CREATE TABLE customer (
customer_id SERIAL PRIMARY KEY
name VARCHAR,
company_id INTEGER,
CONSTRAINT fk_company FOREIGN KEY(company_id) REFERENCES company(company_id)
);
CREATE TABLE company_order (
company_id INTEGER NOT NULL,
order_id INTEGER NOT NULL,
CONSTRAINT fk_company FOREIGN KEY(company_id) REFERENCES company(company_id),
CONSTRAINT fk_order FOREIGN KEY(order_id) REFERENCES orders(order_id)
);
CREATE TABLE customer_order (
customer_id INTEGER NOT NULL,
order_id INTEGER NOT NULL,
CONSTRAINT fk_customer FOREIGN KEY(customer_id) REFERENCES customer(customer_id),
CONSTRAINT fk_order FOREIGN KEY(order_id) REFERENCES orders(order_id)
);
Going back to our feature, the query to retrieve all orders a customer has placed gets a little more complicated now. We need to account for the 2nd path where they may have placed it on behalf of a company.
 OR c2.name = ?;
That's a lot of JOIN
s, each of which has bad performance implications as we traverse the table. Not to mention, we actually
have to traverse through the customer
table twice! You notice that there's an alias each time, either c1 or c2. That's because
if we didn't alias them, then in the WHERE
clause the database would have no idea which instance of customer
we're talking about. Are we
talking about the customer
table we JOIN
ed on when customers ordered directly, or the customer
table we JOIN
ed on when customers
ordered through companies? It'd throw an "ambiguous column name" error. c1 and c2 allow us to specify the two routes to the
customer
table with different aliases. This means they both have to be in the WHERE
clause if we want to make sure we're
getting all orders associated with a given customer, because it's possible that customer could make orders both individually and
on behalf of a company.
Alright so it's not the most efficient solution, but is it really that bad? Yes. Primarily because it doesn't scale. Let's say
we added a third route through which customers could place orders, say on behalf of some entity that we want to track separately
from companies, like a government of a foreign country. We'd then have a government
table and a government_orders
table and in our
query we'd then traverse through the customer
table 3 times. Our WHERE
clause would say WHERE c1.name = ? OR c2.name = ? OR c3.name = ?"
.
Now imagine we add 5 more routes to get to the customer
table from the orders
table. Our query would be a massive mess of JOIN
s, we'd
have to traverse the customer
table N times, and our WHERE
clause would be utterly unreadable. Wouldn't it be great if we could
just traverse customer
once and search by the customer's name once?
Let's flip this problem on its head by starting at the end. Instead of getting all the orders
for a given customer, let's first get the given customer and then get all the orders for that customer. Step one, getting the
customer, is easy.
SELECT customer_id, company_id FROM customer WHERE customer.name = ?;
Ok great, now that we have the customer let's get all orders associated with that customer using the output of that first query.
SELECT orders.order_id
FROM orders
JOIN customer_order ON orders.order_id = customer_order.order_id
WHERE customer_order.customer_id = ?; -- the ? will be populated by the id returned from the previous query.
You may have noticed we can actually optimize this little query and remove the JOIN
because both the orders
table and the
customer_order
table have the field order_id
. So instead of searching for the orders from the orders
table, we can just use customer_order
.
SELECT customer_order.order_id
FROM customer_order
WHERE customer_order.customer_id = ?; -- the ? will be populated by the id returned from the previous query.
Ok that's great. We've optimized the query to not have to JOIN
with the customer
or orders
tables at all. However, we've split it out
into two different queries, which means we'd have to write some logic in code to stitch them together. Logic that could break or cause
bugs. Wouldn't it be nice if we could do both queries together? Enter the WITH
clause!
WITH customer_query AS (SELECT customer_id, company_id FROM customer WHERE customer.name = ?)
SELECT customer_order.order_id
FROM customer_order
JOIN customer_query ON customer_query.customer_id = customer_order.customer_id
WHERE customer_order.customer_id = customer_query.customer_id;
At first glance it may seem like we're still JOIN
ing on the customer
table. After all, we're doing a JOIN
on the customer_id
. But if
you look closely you'll see that the JOIN
actually happens on the output of the WITH
clause, labeled as customer_query
. This means that
it's only JOIN
ing on the specific subset of data that we got when we did the first query inside the WITH
. Instead of having to traverse
the entire customer
table, it only needs to look at one row! Yes it's a JOIN
, but a JOIN
on a set of data with only one row barely has
an effect on performance at all.
Awesome, but what about the other path through the data? With what we have now we can get all orders placed directly by a customer
blazingly fast, but we still need to also get all the orders placed on behalf of a company. How can we possibly do that in the same query?
Enter the UNION
clause!
WITH customer_query AS (SELECT customer_id, company_id FROM customer WHERE customer.name = ?)
SELECT customer_order.order_id
FROM customer_order
JOIN customer_query ON customer_query.customer_id = customer_order.customer_id
WHERE customer_order.customer_id = customer_query.customer_id
UNION
SELECT company_order.order_id
FROM company_order
JOIN customer_query ON customer_query.company_id = company_order.company_id
WHERE company_order.company_id = customer_query.company_id;
Note that we now JOIN
on the same single-line subset of the customer
table defined in our WITH
clause as customer_query
, but this time
we're joining by the company_id
. Also note that we did the same performance optimization to get the order_id
from company_order
rather
than having to JOIN
on the orders
table. Ta-da! Now we have all the data we need, we didn't have to JOIN
on orders
or on the full customer
table at all, and our query will scale as we add more and more paths through our database.
That's all I've got for this post! I just thought it was a cool optimization, so I decided to share it. If you're wondering why I learned
about this, I work as an engineer on the promotions team at Target. Any time there's a sale anywhere at Target, online or in store,
my team facilitated that. There was a need for people to be able to search for all the promotions that affected a given item. The problem
is that an item can be added in many distinct ways to an offer. It can be added directly by id by saying "this item is on this offer".
It can be added through the department by saying "this item is in the menswear department and the menswear department is on this offer".
It can be added through the brand by saying "this item is a part of the Levi's brand and the Levi's brand is on this offer". I won't bore
you too much, but there's 6 or 7 different paths through the data, and some of them could be combined (I.E. "this item is a part of menswear
and the Levi's brand and menswear belonging to the Levi's brand is part of this offer").


| | |
- display_inventory()
- Prints the current player inventory.
- drop(item_name)
- Drops items into current room.
Parameters:
item_name(str): String description of name of item to be dropped.
- examine(item_name)
- Prints a detailed description of an item.
Parameters:
item_name(str): Name of item in dictionary.
- game_loader(path)
- Methods that validates the yaml file path, and if valid
it loads the game from the CLI.
Parameters:
path(str): A String that contains the file path to the yaml file.
Returns:
bool: Returns true if file path is valid.
Returns false if file path is invalid.
- loading_items(data)
- Loads the items of the game. All the items are created along with their
names, properties, and descriptions.
Parameters:
data(dict): Nested dictionaries containing
all information of the game in regard to items.
- loading_map(data)
- Loads the map of the game. All the rooms are created along with their
neighboring rooms, doors, descriptions, and items.
Parameters:
data(dict): Nested dictionaries containing
all information of the game in regard to rooms.
- loading_player(data)
- Loads the player specifications. The player is created along with his
position and inventory.
Parameters:
data(tuple): A tuple containing the player position and inventory.
- move(cardinal)
- Moves the player from one room to another if room exists and door is
open.
Parameters:
cardinal(str): String that points to a valid cardinal.
i.e {North, East, South, West}
- pick_up(item_name)
- Picks up items from current room.
Parameters:
item_name(str): String description of name of item to be picked up.
- room_to_screen()
- Prints the room name, room description and room items.
- saving()
- Saving your progress at any given time as a yaml file.
- use_key(cardinal, key)
- Player uses key at a door in a given cardinal,
if key and cardinal match, method will open the door.
Parameters:
cardinal(str): String that points to a valid cardinal.
i.e {North, East, South, West}
key(str): String that represents the name of the key.
- user_command(command)
- Perform the method calls to play the game via a dictionary.
Parameters:
command(tuple): Tuple containing a verb, an object, and a target.
|


Our class were asked to create a product and manufacturing company from scratch. Above is the product I created; "Sorry Mom Tattoo Ink". In addition to multiple logos we were asked to create packaging design for the container and the box in which it would be sold, an ad for the product and a full write up on the product and its company.
Product Design
Fall 2015
Visual Communication Design 1


New York City (NYC) is the most populous
city in the United States. The estimated population in NYC in 2019 was 8,336,817
distributed over about 302.6 square miles. NYC is also the most densely populated
major city in the United States. With almost 20 million people in
its metropolitan
statistical area and approximately 23 million in its combined statistical area,
it is one of the world's most populous megacities.
New York City has been described as the cultural, financial, and media capital of
the world, significantly influencing commerce, entertainment, research,
technology, education, politics, tourism, art, fashion, and sports [1].
Situated on one of the
world's largest natural harbors, New York City is composed of
five boroughs, each of which is a county of the State of New York. The five
boroughs are: Brooklyn, Queens, Manhattan, the Bronx,
and Staten Island. At its core is Manhattan, a
densely populated borough that’s among the world’s
major commercial, financial and cultural centers. Its iconic sites include
skyscrapers such as the Empire State Building and sprawling Central Park.
Broadway theater is staged in neon-lit Times Square.
With the above statistics and information,
one kind easily imagine that living in New York City can be very exciting especially
if you are a city person. However, it can also be very expensive, especially
the housing. While on the other hand, NYC has always been very attractive for
investors all over the world, whether to invest in the housing market, opening restaurants,
bars, entertainment center, etc. Whatever the perspective objectives are, a comprehensive
understanding of different areas in NYC with the corresponding statistics including
housing prices, & venues information will be very critical for either a
personal buyer or an investor. Although one can easily search for information on
the internet for an area of interest, combined information of average housing
price and venues information is not readily available. Thus, the primary objective
for this study is to perform a comprehensive investigation and analysis of the
mean unit housing prices in different neighborhoods of New York City as well as
to explore the surrounding venues for each neighborhood and combine this two
information to show on the same map.
In this study, eventually, two maps will be created:
1.1 A map of housing located at different neighborhood
of New York City for the five boroughs, each borough shown with a different
color. A popup label was created for each building labeled with building class
category name, borough, neighborhood, and the mean unit housing price.
1.2 A map of clustered neighborhoods of NYC with
combined information of mean unit housing price and venues information: popup
labels showing the borough, neighborhood, top surrounding venues
and the mean unit housing prices. The neighborhoods will also be clustered into
4 clusters by DBSCAN method and a name will be given to each cluster based on the
appearance frequency of different venues for each cluster.
The following data were used for the present study:
· The
Department of Finance’s Rolling Sales files of New York City, which lists
properties that sold in the last twelve-month period in New York City for all
tax classes [2]. These files include information on:
o
The neighborhood
o
Building type
o
Square footage
o
Sale price
o
Other data
· Geocoder.arcgis
method was used to get the latitudes and longitudes pairs of each neighborhood in
the housing sales file.
· Foursquare
API was used to explore nearby venues for each neighborhood of NYC [3].
3.1 Data acquisition
and cleaning
In order to be able to combine the housing
sales information of New York City with nearby venues data, a file
containing both housing sales prices as well as the housing location including
borough, neighborhood as well as the zip code will be needed. The
nyc-rolling-sales.csv file, which is available both at the Kaggle website as
well as the nyc.gov site shown in the links above, contains all this
information.
After data was downloaded, data cleaning was performed.
There are several issues with the dataset. First, some of the housing/building has
0 sale prices. Based on the data explanation sheet, a $0 sale indicates that
there was a transfer of ownership without a cash consideration. There can be a number of reasons for a $0 sale including transfers of
ownership from parents to children. Thus, these building sales will not serve
my purpose of study and was dropped from the dataset.
Second, for some buildings sold, it has a 0 zip code in the file. As the zip code will be used to
retrieve the latitudes and longitudes data, I decided to drop those rows with 0
zip code data as well.
Third, the dataset also has a column indicating the building
class code and the building type, e.g, rentals-walk up apartments, condominium,
dwelling house, etc. I thought this is very useful information to show along
with the sales price on one of the map I was intending
to create. But the building code, which is a number code, might be not very useful
for the current study. Thus, I decide to split the column name to only show the
building class category name.
Fourth, the sales price contained in this file is the sale
price for the building, which can be 1 or multiple units. Thus, I divided the sales
price with the total units to obtain the unit sale price, whose mean (average across
several similar type of sales) will be used to be shown on the maps created.
Furthermore, although there are also square footage information,
including the land square feet and the gross square feet, these information was
not used for price/square feet calculation, due to the fact that it was not
clear whether the square footage really correspond to the perspective units
sold.
Finally, the dataset was grouped by borough, neighborhood,
zip code and building class category name and the mean/average unit sales price
was obtained, which will be shown on the maps to be created.
3.2 Explore the neighborhoods in New York City
First, geocoder.arcgis was used to
obtain the latitudes and longitudes coordinates of NYC neighborhoods through
the zip codes. To accomplish this, all the unique zip code was extracted and
converted to a list. The corresponding latitudes and longitudes coordinates was obtained with arcgis. Then, a dictionary was created
with the zip codes as the keys and the latitudes and longitudes pairs as the corresponding
values. Finally, the latitudes and longitudes values were filled into the
nyc_grouped datasets containing mean house sales prices explained above.
3.3 Explore
the nearby venues of NYC to combine with house sales information
Foursquare API was used to explore the neighborhoods and
segment them. To further simplify the dataset, I grouped the dataset again by
only the borough, neighborhood and zip code. Doing this
mean that we are not going to be able to show the building class category
names, which reduce the rows of data from over 4000 to about 600. Then the mean
unit sales price was obtained. The drawback of this mean unit sale price to be
shown on the second map to be created is that it does not show what type of
building was sold. Rather, it is just an average of building sales price based
on neighborhood. Thus, the mean unit price information shown on the 2nd
map will be much more general compared to the mean unit price shown on the 1st
map created above.
To explore nearby venues, I set the radius to be 180
meters and limit to 30 venues for each item from their latitude and
longitude information to be searched. As there are 613 row
in the new grouped dataset, the code will run 613 searches, although some row
have duplicate latitude and longitude pairs.
The output file of the searched venues was
called “nyc_venues”. A snap shot of the file was shown below:
In summary, 247 unique venue categories
was returned from the search.
3.4 Analyze each
neighborhood
By applying pandas.get_dummies method, a
file (nyc_onehot) containing the encoded venue category information was obtained.
The borogh, neighborhood, zip code and a combined location information was also
included into this nyc_onehot file. Then the nyc_onehot file was grouped by
borough, neighborhood, zip code and location with the mean unit sale price
obtained.
To better understand venues distribution
characteristics for each neighborhood, I sorted the venues to return different
levels of most common venues for each neighborhood. Below is the table created:
3.5 Cluster the
neighborhoods
Clustering, an unsupervised learning process,
is unique way for us to understand data by dividing the entire data into groups/clusters
based on the patterns in the data.
First, I tried K-means clustering method
to cluster the neighborhoods. K-means is a centroid-based algorithm, or a
distance-based algorithm, where we calculate the distances to assign a point to
a cluster. In K-Means, each cluster is associated with a centroid. The main
objective of the K-Means algorithm is to minimize the sum of distances between
the points and their respective cluster centroid [4].
To determine the best number of K, the
elbow method using distortion was performed. However, no elbow was found from
the graph. This does not mean that there are no clusters in the data. No
elbow means that the algorithm used cannot separate clusters. Thus, I decided
to use the DBSCAN method instead.
DBSCAN
[5]:
·
stands for “density based
spatial clustering of applications with noise”
·
does not require the user to
set the number of clusters a priori
·
can capture clusters of
complex shapes
·
can identify points that are
not part of any cluster (very useful as outliers detector)
·
is somewhat slower than
agglomerative clustering and k-means, but still scales to relatively large
datasets.
·
works by identifying points
that are in crowded regions of the feature space, where many data points are
close together (dense regions in feature space)
·
Points that are within a dense
region are called core samples (or core points)
A total of 4 clusters was
obtained from DBSCAN:
However, I would like to show the cluster on
the popup label of the map as well. It would be more useful to show the cluster
with a name indicating its features by analyzing the venues data. Thus, a bar
chart of the venues frequency which is the sum of the top 1, 2 & 3 most
common venues (only selected the top 20 venues for the top 1, 2 & 3 most
common venues by sorting the venues frequency) was created using seaborn
facetgrid method. See the chart below:
Based on the bar charts above, I name the
clusters as the following:
·
Cluster -1: Social, Shopping
& Entertainment Complex
·
Cluster 0: French Restaurant,
Bar & Misc
·
Cluster 1: Chinese Restaurant
& Bar_1
·
Cluster -1: Chinese Restaurant
& Bar_2
Note that as cluster 1 and -1 show pretty
simiar features and they both don’t have a lot of venues nearby, I just name
them based on the several venues they had and give a number 1 and 2 to
distinguish them.
4.1 Map 1
(correspond to section 1.1):
The grouped data used to create the 1st map I explained
in section 1.1 is shown below:
The 1st map was created with python folium library:
1.1 A map of housing located at different neighborhood of New York City for the
five boroughs, each borough shown with a different color. A couple of snapshot of the map are shown below:
As can be seen, each borough was denoted by a different
fill color. And each group of building sold was denoted by its location,
especially its zip code on the map. A popup label was created to display some
key information including the neighborhood, borough name, building class
category name, and the mean unit price sold for this type of building. This map
can be very useful for people who are looking for buying a
either an apartment, a house, or investing apartments. Building clicking on the
map, one can easily find the mean unit sale prices as well as its neighborhood
and how the price is compared to similar or different building in the same or
different neighborhoods.
4.2 Map 2 (correspond to section 1.2)
The venues data searched was merged with
the nyc_grouped 2 data, which includes the mean unit building sales price info.
A snap shot of the merged data was shown below:
Another thing I did was that I created another
column which shows the joined name of the top 3 most common venues, named “Top_Common_Venues”.
This column is included in the merged file shown above.
Finally, we can visualize the data in a
map using Folium:
As can be seen, the map
shows clustered neighborhoods of NYC with combined information of mean unit
housing price and venues information. The popup labels display the borough,
neighborhood, top surrounding venues and the mean unit
housing prices. This map will be very useful for house buyer or investors to
review and compare housing sale prices as well as what is the characteristic
venues nearby. The top venues information shown on the popup label will help
the buyers or investors decide where might better suite their purpose when
making decision on buying or investing a property.
In the current study, two maps were created: one shows the NYC housing
sold at different neighborhoods in the 5 boroughs with different color notations.
Each house sold was shown on the map with a popup label with information
including: neighborhood, borough name, building class category name,
and the mean unit price sold for this type of building. This map will be useful
to house buyers or investors to explore the type of buildings/housing they are
interested in and to compare the neighborhoods as well as the price difference across
different neighborhoods and boroughs.
For the second map
created, nearby venues information was combined with the average unit sale price
for housing in that neighborhood. The detailed information of building class
category name was sacrificed to only obtain an overall average price for all
the different building sold in that neighborhood. The reason for this is to
reduce the amount of data for nearby venues exploration and to simply the
display on the map. Then both K-means clustering and DBSCAN methods was applied
to the data for neighborhood clustering and DBSCAN method was chosen because no
elbow was found in the elbow method chart. The popup labels display the
borough, neighborhood, top surrounding venues and the
mean unit housing prices. This map will be very useful for house buyer or investors
to review and compare housing sale prices as well as what is the characteristic
venues nearby.
Combined use of Map 1 and Map 2 created in this study will
be even more powerful for house buyers or investors to get more comprehensive
information on average housing price, building class category names, neighborhood and top venues nearby.
In this study, two maps were created to help especially
house buyers or investors to explore different types of building units and
compare the prices based on building types as well neighborhoods changes. The
second map created can be further used to explore nearby venues to get more
comprehensive understanding of the buildings/housing in New York City.
References:
[1] https://en.wikipedia.org/wiki/New_York_City
[2] https://www1.nyc.gov/site/finance/taxes/property-rolling-sales-data.page
[3] Foursquare API
[4]https://www.analyticsvidhya.com/blog/2019/08/comprehensive-guide-k-means-clustering/


To use this feature, select Maintain | Stratum Rejection Limits. For each stratum id you can enter a historical bias, historical random uncertainty and historical systematic uncertainty for the current detector. These values may also be obtained from Stratum Authority disk files by using File | Get External Data | Stratum Authority File. For verification measurements the mass acceptance test is as follows:
Total uncertainty (delta) = sqrt (random^2 + systematic^2)
Then the acceptance range is:
bias - 3 * delta <= ((declared mass - measured mass) / declared mass) <= bias + 3 * delta
If the measured mass is outside this acceptance range, then the measurement will be marked as having failed the quality test on all results displays and printouts and the discrepancy/anomaly flag will be set to “Y” and the delta value will be reported as the relative standard deviation in the PSA/Logsheet output file.


Picar.io is proof-of-concept multiplayer game for the Pico-8 virtual console based on Agar.io. It is the first large multiplayer game to be made for the Pico-8, capable of supporting 64+ simultaneous players. I wrote the server for this project.
Built Python server that updates clients and deployed it on Google Compute Engine.
Implemented spatial hashing, reducing data needed to update clients per tick.
Implemented seamless add/drop player functionality


JAMStack deploy
Last login: Thu Dec 22 00:26:31 on ttys002
Your analyst has you mixed up with another patient. Don't believe a thing he tells you.
~/d/g/jamon
❯
❯
❯
whoami
JAMStack dev from
an uknown location
~/d/g/jamon
❯
❯
❯
git status
On branch master
Your branch is up-to-date with 'origin/master'.
Changes to be committed:
(use "git reset HEAD <file>..." to unstage)
new file: deployment.md
~/d/g/jamon
❯
❯
❯
cat deployment.md
If you are seing this, then something went wrong with getting the description on the used hosting solution.
Oh well, at least the site is online...
~/d/g/jamon
❯
❯
❯


#
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
"""
A collections of builtin avro functions
"""
from pyspark import since, SparkContext
from pyspark.rdd import ignore_unicode_prefix
from pyspark.sql.column import Column, _to_java_column
from pyspark.util import _print_missing_jar
[docs]@ignore_unicode_prefix
@since(3.0)
def from_avro(data, jsonFormatSchema, options={}):
"""
Converts a binary column of Avro format into its corresponding catalyst value.
The specified schema must match the read data, otherwise the behavior is undefined:
it may fail or return arbitrary result.
To deserialize the data with a compatible and evolved schema, the expected Avro schema can be
set via the option avroSchema.
Note: Avro is built-in but external data source module since Spark 2.4. Please deploy the
application as per the deployment section of "Apache Avro Data Source Guide".
:param data: the binary column.
:param jsonFormatSchema: the avro schema in JSON string format.
:param options: options to control how the Avro record is parsed.
>>> from pyspark.sql import Row
>>> from pyspark.sql.avro.functions import from_avro, to_avro
>>> data = [(1, Row(name='Alice', age=2))]
>>> df = spark.createDataFrame(data, ("key", "value"))
>>> avroDf = df.select(to_avro(df.value).alias("avro"))
>>> avroDf.collect()
[Row(avro=bytearray(b'\\x00\\x00\\x04\\x00\\nAlice'))]
>>> jsonFormatSchema = '''{"type":"record","name":"topLevelRecord","fields":
... [{"name":"avro","type":[{"type":"record","name":"value","namespace":"topLevelRecord",
... "fields":[{"name":"age","type":["long","null"]},
... {"name":"name","type":["string","null"]}]},"null"]}]}'''
>>> avroDf.select(from_avro(avroDf.avro, jsonFormatSchema).alias("value")).collect()
[Row(value=Row(avro=Row(age=2, name=u'Alice')))]
"""
sc = SparkContext._active_spark_context
try:
jc = sc._jvm.org.apache.spark.sql.avro.functions.from_avro(
_to_java_column(data), jsonFormatSchema, options)
except TypeError as e:
if str(e) == "'JavaPackage' object is not callable":
_print_missing_jar("Avro", "avro", "avro", sc.version)
raise
return Column(jc)
[docs]@ignore_unicode_prefix
@since(3.0)
def to_avro(data, jsonFormatSchema=""):
"""
Converts a column into binary of avro format.
Note: Avro is built-in but external data source module since Spark 2.4. Please deploy the
application as per the deployment section of "Apache Avro Data Source Guide".
:param data: the data column.
:param jsonFormatSchema: user-specified output avro schema in JSON string format.
>>> from pyspark.sql import Row
>>> from pyspark.sql.avro.functions import to_avro
>>> data = ['SPADES']
>>> df = spark.createDataFrame(data, "string")
>>> df.select(to_avro(df.value).alias("suite")).collect()
[Row(suite=bytearray(b'\\x00\\x0cSPADES'))]
>>> jsonFormatSchema = '''["null", {"type": "enum", "name": "value",
... "symbols": ["SPADES", "HEARTS", "DIAMONDS", "CLUBS"]}]'''
>>> df.select(to_avro(df.value, jsonFormatSchema).alias("suite")).collect()
[Row(suite=bytearray(b'\\x02\\x00'))]
"""
sc = SparkContext._active_spark_context
try:
if jsonFormatSchema == "":
jc = sc._jvm.org.apache.spark.sql.avro.functions.to_avro(_to_java_column(data))
else:
jc = sc._jvm.org.apache.spark.sql.avro.functions.to_avro(
_to_java_column(data), jsonFormatSchema)
except TypeError as e:
if str(e) == "'JavaPackage' object is not callable":
_print_missing_jar("Avro", "avro", "avro", sc.version)
raise
return Column(jc)
def _test():
import os
import sys
from pyspark.testing.utils import search_jar
avro_jar = search_jar("external/avro", "spark-avro", "spark-avro")
if avro_jar is None:
print(
"Skipping all Avro Python tests as the optional Avro project was "
"not compiled into a JAR. To run these tests, "
"you need to build Spark with 'build/sbt -Pavro package' or "
"'build/mvn -Pavro package' before running this test.")
sys.exit(0)
else:
existing_args = os.environ.get("PYSPARK_SUBMIT_ARGS", "pyspark-shell")
jars_args = "--jars %s" % avro_jar
os.environ["PYSPARK_SUBMIT_ARGS"] = " ".join([jars_args, existing_args])
import doctest
from pyspark.sql import Row, SparkSession
import pyspark.sql.avro.functions
globs = pyspark.sql.avro.functions.__dict__.copy()
spark = SparkSession.builder\
.master("local[4]")\
.appName("sql.avro.functions tests")\
.getOrCreate()
globs['spark'] = spark
(failure_count, test_count) = doctest.testmod(
pyspark.sql.avro.functions, globs=globs,
optionflags=doctest.ELLIPSIS | doctest.NORMALIZE_WHITESPACE)
spark.stop()
if failure_count:
sys.exit(-1)
if __name__ == "__main__":
_test()


MONTHS_BETWEEN Function
MONTHS_BETWEEN determines the number of months between two dates.
If the first date is later than the second date, the result is positive; otherwise, the result is negative.
If either argument is null, the result is NULL.
Syntax
MONTHS_BETWEEN ( date1, date2 )
Arguments
- date1
-
An expression, such as a column name, that evaluates to a valid date or time stamp value.
- date2
-
An expression, such as a column name, that evaluates to a valid date or time stamp value.
Return Type
FLOAT8
The whole number portion of the result is based on the difference between the year and month values of the dates. The fractional portion of the result is calculated from the day and timestamp values of the dates and assumes a 31-day month.
If date1 and date2 both contain the same date within a month (for example, 1/15/14 and 2/15/14) or the last day of the month (for example, 8/31/14 and 9/30/14), then the result is a whole number based on the year and month values of the dates, regardless of whether the timestamp portion matches, if present.
Examples
The following example returns the months between 1/18/1969 and 3/18/1969:
select months_between('1969-01-18', '1969-03-18') as months; months ---------- -2
The following example returns the months between the first and last showings of an event:
select eventname, min(starttime) as first_show, max(starttime) as last_show, months_between(max(starttime),min(starttime)) as month_diff from event group by eventname order by eventname limit 5; eventname first_show last_show month_diff --------------------------------------------------------------------------- .38 Special 2008-01-21 19:30:00.0 2008-12-25 15:00:00.0 11.12 3 Doors Down 2008-01-03 15:00:00.0 2008-12-01 19:30:00.0 10.94 70s Soul Jam 2008-01-16 19:30:00.0 2008-12-07 14:00:00.0 10.7 A Bronx Tale 2008-01-21 19:00:00.0 2008-12-15 15:00:00.0 10.8 A Catered Affair 2008-01-08 19:30:00.0 2008-12-19 19:00:00.0 11.35


You can use XMLHttpRequest (XHR: AJAX's engine) to pull JavaScript down to the client as needed. An alternative approach tested here is using the Document Object Model (DOM) to create a new <script> element, which grabs the script using the standard "src" attribute. An advantage of this is that you can cross domains with this approach, which is generally forbidden when using XHR.
Try these steps below, preferably in order.
See the On-Demand JavaScript page at AjaxPatterns.org for a more thorough treatment of this approach.


|
Bullet Collision Detection & Physics Library
|
btGjkEpaSolver contributed under zlib by Nathanael Presson More...
#include <btGjkEpa2.h>
Classes | |
| struct | sResults |
Static Public Member Functions | |
| static int | StackSizeRequirement () |
| static bool | Distance (const btConvexShape *shape0, const btTransform &wtrs0, const btConvexShape *shape1, const btTransform &wtrs1, const btVector3 &guess, sResults &results) |
| static bool | Penetration (const btConvexShape *shape0, const btTransform &wtrs0, const btConvexShape *shape1, const btTransform &wtrs1, const btVector3 &guess, sResults &results, bool usemargins=true) |
| static btScalar | SignedDistance (const btVector3 &position, btScalar margin, const btConvexShape *shape, const btTransform &wtrs, sResults &results) |
| static bool | SignedDistance (const btConvexShape *shape0, const btTransform &wtrs0, const btConvexShape *shape1, const btTransform &wtrs1, const btVector3 &guess, sResults &results) |
btGjkEpaSolver contributed under zlib by Nathanael Presson
Definition at line 31 of file btGjkEpa2.h.
|
static |
Definition at line 937 of file btGjkEpa2.cpp.
|
static |
Definition at line 973 of file btGjkEpa2.cpp.
|
static |
Definition at line 1021 of file btGjkEpa2.cpp.
|
static |
Definition at line 1073 of file btGjkEpa2.cpp.
|
static |
Definition at line 931 of file btGjkEpa2.cpp.


Welcome to Inventory Lite
Inventory Lite is committed to provide immediate, prioritized and measurable results with no hidden costs. We will also train and explain by example the appropriate way to maintain the levels of inventory that your company requires to stay profitable.
We help in reducing your cost for import/export, freight forwarding, coast to coast warehousing, storage, kit building, inventory control, purchasing, materials management, transportation, supply, stocking and more...
Our creativity can help to setup suppliers, reduce freight costs, shorten lead time, improve shipping performance, and reduce raw material purchasing & labor costs to improve your cash flow.


This chapter discusses the rule system in PostgreSQL. Production rule systems are conceptually simple, but there are many subtle points involved in actually using them.
Some other database systems define active database rules, which are usually stored procedures and triggers. In PostgreSQL, these can be implemented using functions and triggers as well.
The rule system (more precisely speaking, the query rewrite rule system) is totally different from stored procedures and triggers. It modifies queries to take rules into consideration, and then passes the modified query to the query planner for planning and execution. It is very powerful, and can be used for many things such as query language procedures, views, and versions. The theoretical foundations and the power of this rule system are also discussed in On Rules, Procedures, Caching and Views in Database Systems and A Unified Framework for Version Modeling Using Production Rules in a Database System.


|
Bullet Collision Detection & Physics Library
|
This class is not enabled yet (work-in-progress) to more aggressively activate objects. More...
#include <btActivatingCollisionAlgorithm.h>
Public Member Functions | |
| virtual | ~btActivatingCollisionAlgorithm () |
| Public Member Functions inherited from btCollisionAlgorithm | |
| btCollisionAlgorithm () | |
| btCollisionAlgorithm (const btCollisionAlgorithmConstructionInfo &ci) | |
| virtual | ~btCollisionAlgorithm () |
| virtual void | processCollision (const btCollisionObjectWrapper *body0Wrap, const btCollisionObjectWrapper *body1Wrap, const btDispatcherInfo &dispatchInfo, btManifoldResult *resultOut)=0 |
| virtual btScalar | calculateTimeOfImpact (btCollisionObject *body0, btCollisionObject *body1, const btDispatcherInfo &dispatchInfo, btManifoldResult *resultOut)=0 |
| virtual void | getAllContactManifolds (btManifoldArray &manifoldArray)=0 |
Protected Member Functions | |
| btActivatingCollisionAlgorithm (const btCollisionAlgorithmConstructionInfo &ci) | |
| btActivatingCollisionAlgorithm (const btCollisionAlgorithmConstructionInfo &ci, const btCollisionObjectWrapper *body0Wrap, const btCollisionObjectWrapper *body1Wrap) | |
Additional Inherited Members | |
| Protected Attributes inherited from btCollisionAlgorithm | |
| btDispatcher * | m_dispatcher |
This class is not enabled yet (work-in-progress) to more aggressively activate objects.
Definition at line 22 of file btActivatingCollisionAlgorithm.h.
|
protected |
Definition at line 20 of file btActivatingCollisionAlgorithm.cpp.
|
protected |
Definition at line 27 of file btActivatingCollisionAlgorithm.cpp.
|
virtual |
Definition at line 43 of file btActivatingCollisionAlgorithm.cpp.


{{ page.title }}
{% include sharebuttons.html %}
{{ content }}
---
layout: default
---
{{ page.title }}
{% include sharebuttons.html %}
{{ content }}
Software Engineer living in Santa Cruz, CA, creator of BitListen.com.


Dear {{ user.username }},
To reset your password click on the following link:
{{ url_for('auth.reset_password', token=token, _external=True) }}
Sincerely,
The Administration


--- title: About layout: single permalink: /about/ author_profile: true classes: wide header: teaser: "/assets/images/bio-photo.jpg" ---
Hi!
I am a final year Computer Science & Engineering student.
I develop open source software related to AI and Web.
The top global nominee from India for NASA Space Apps Challenge 2018, and one of 1200 Microsoft Student Partners across the world.
I currently lead the GNU Linux Users Group at my college. Feel free to reach out to me on my social channels.


scalation
package scalation
The scalation
package specifies system-wide constants for directory paths.
Sub-packages may wish to define 'BASE-DIR = DATA_DIR + ⁄ + <package>' in their
own 'package.scala' files. For maintainability, directory paths should only
be specified in 'package.scala' files.
- Alphabetic
- By Inheritance
- scalation
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Type Members
Value Members
-
val
BASE: String
Base directory for ScalaTion (pick one, comment out the rest) Under module differentiated, each module (scalation_mathstat, scalation_modeling and scalation_models) will have its own base directory, rather than sharing a common base directory.
-
val
DATA_DIR: String
File system path for input/output data directory Use 'SCALATION_HOME' environment variable or else BASE directory "."
-
val
LOG_DIR: String
File system path for log (log/file output) directory Use 'SCALATION_HOME' environment variable or else BASE directory "."
-
val
MEM_MAPPED_DIR: String
File system path for memory mapped files directory Use 'SCALATION_HOME' environment variable or else BASE directory "."
-
val
SEP: String
The file path separation character: '/' for Linux/Mac, '\' for Windows Use either 'SEP' or '⁄' for portability, i.e., do not use '/' or '\'.
-
val
SRC_DIR: String
File system path for src (source code) directory Use 'SCALATION_HOME' environment variable or else BASE directory "."
- val SRC_SCALA_DIR: String
-
val
STORE_DIR: String
File system path for database storage directory Use 'SCALATION_HOME' environment variable or else BASE directory "."
-
def
removeLast(s: String): String
Remove the last path element from the file/directory pathname.
Remove the last path element from the file/directory pathname.
- s
the string to be so truncated
-
def
setParallelism[A](n: Int)(block: ⇒ A): A
Set the default parallelism level (number of threads to use) for an arbitrary block of code: 'parallel (n) { block }' when running parallel tasks.
Set the default parallelism level (number of threads to use) for an arbitrary block of code: 'parallel (n) { block }' when running parallel tasks. Then restore the old parallelism level.
- n
number of threads
- See also
-for-scala-2-10-parallel-collections/18574345
stackoverflow.com/questions/17865823/how-do-i-set-the-default-number-of-threads
- val ⁄: String
-
object
GenIndexHtml
extends App
The
GenIndexHtml
object is used to create "index.html" files in source code directories (main and test) to enable Web browsing of source code.The
GenIndexHtml
object is used to create "index.html" files in source code directories (main and test) to enable Web browsing of source code. > run-main scalation.GenIndexHtml -
object
UpVersion
The 'UpVersion' object is used to update the version number in the source code.
-
object
UpVersionAll
extends App
The 'UpVersionAll' object updates the version number of all source (.scala) files at or below the 'currentDir' (see 'UpVersion').
The 'UpVersionAll' object updates the version number of all source (.scala) files at or below the 'currentDir' (see 'UpVersion'). > run-main scalation.UpVersionAll
-
object
UpVersionFile
extends App
The 'UpVersionFile' object updates the version number of a single source (.scala) file.
The 'UpVersionFile' object updates the version number of a single source (.scala) file. > run-main scalation.UpVersionFile
-
object
WorkerTest
extends App
The
WorkerTest
object tests theWorker
class vs.The
WorkerTest
object tests theWorker
class vs. Scala's built-in '.par' on the matrix multiplication problem. > run-main scalation.frame.WorkerTest -
object
scalationTest
extends App
The
scalationTest
object is used test thescalation
package object.The
scalationTest
object is used test thescalation
package object. > run-main scalation.scalationTest


Preparation time
less than 30 mins
Cooking time
10 to 30 mins
Serves
Makes 12 cupcakes
Dietary
These super-cute Christmas cupcakes are perfect for baking with children.
Preheat the oven to 170C/325F/Gas 3. Line a 12-hole muffin tray with paper cases.
Beat the butter and sugar together until light and creamy. Gradually beat in the eggs until well combined. Sift in the flour and cocoa powder and mix until combined. Fold in the milk, melted chocolate and Irish cream liqueur, if using.
Spoon the mixture into the muffin cases and bake for 20-25 minutes, or until well risen and lightly firm to the touch. Remove the cakes from the tin and set aside to cool on a cooling rack.
For the icing, heat the chocolate and cream in a saucepan over a low heat until the chocolate has melted. Whisk the mixture until smooth and set aside to cool slightly.
To decorate the cupcakes, spread the icing over the top of the cupcakes. Spoon the remaining icing into an icing bag fitted with a small nozzle.
Press a chocolate button onto the cake as a nose, then stick a crisp-coated chocolate on top using a little icing. Stick on two slices of marshmallows as the eyes, and use the black writing icing for the pupils. Stick on the pretzels as the ears.


'''
Copyright 2017, Fujitsu Network Communications, Inc.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
'''
import datetime
from Framework import Utils
from Framework.Utils import data_Utils, file_Utils
import os
from Framework.Utils.testcase_Utils import pNote
[docs]class CIregressionActions(object):
def __init__(self):
"""
constructor
"""
self.resultfile = Utils.config_Utils.resultfile
self.datafile = Utils.config_Utils.datafile
self.logsdir = Utils.config_Utils.logsdir
self.filename = Utils.config_Utils.filename
self.logfile = Utils.config_Utils.logfile
[docs] def write_to_file(self, key, system_name):
"""
Here we are writing to the file which keyword ran and on which system
Argument:
Key: It is basically the keyword name followed by step num in the test case
system_name: It is the system_name on which the step ran
Returns:
True
"""
data_Utils.update_datarepository({"output_file":self.logfile})
with open(self.logfile,"a+") as fo:
fo.write("\n"+"****************************")
fo.write("\n"+key+" ran")
fo.write("\n"+"Ran on "+system_name)
fo.write("\n"+"****************************"+"\n")
return True
[docs] def once_per_tc_with_system_name_given(self, system_name, step_num):
"""
It is used to test the functionality of once per tc with system name given in the test case
Arguments:
system_name: Name of the system on which it needs to be run
step_num: It is the step_num in the test case file
Returns:
Returns True
"""
wdesc = "Once per tese case with system name given"
pNote(wdesc)
key = 'once_per_tc_with_system_name_given_'+str(step_num)
self.write_to_file(key, system_name)
return True
[docs] def once_per_tc_with_no_name_given(self, system_name, step_num):
"""
It is used to test the functionality of once per tc with no system name given in the test case
Arguments:
system_name: Name of the system on which it needs to be run
step_num: It is the step_num in the test case file
Returns:
Returns True
"""
wdesc = "Once per testcase with system name not given"
pNote(wdesc)
key = 'once_per_tc_with_no_name_given_'+str(step_num)
self.write_to_file(key, system_name)
return True
[docs] def once_per_tc_with_error(self, system_name, step_num):
"""
It is used to test the functionality of once per tc with error in the test case
Arguments:
system_name: Name of the system on which it needs to be run
step_num: It is the step_num in the test case file
Returns:
Returns True
"""
wdesc = "Once per testcase with error"
pNote(wdesc)
key = 'once_per_tc_with_error_'+str(step_num)
self.write_to_file(key, system_name)
raise Exception("This is raised in CIregressionActions.once_per_tc_with_error")
return False
[docs] def standard_with_system_name_given(self, system_name, step_num):
"""
It is used to test the functionality of standard with system name given in the test case
Arguments:
system_name: Name of the system on which it needs to be Running
step_num: It is the step_num in the test case file
Returns:
Returns True
"""
wdesc = "Standard with system name given"
pNote(wdesc)
key = 'standard_with_system_name_given_'+str(step_num)
self.write_to_file(key, system_name)
return True
[docs] def standard_with_system_name_not_given(self, system_name, step_num):
"""
It is used to test the functionality of standard with no system name given in the test case
Arguments:
system_name: Name of the system on which it needs to be run
step_num: It is the step_num in the test case file
Returns:
Returns True
"""
wdesc = "Standard with system name not given"
pNote(wdesc)
key = 'standard_with_system_name_not_given_'+str(step_num)
self.write_to_file(key, system_name)
return True
[docs] def standard_with_error(self, system_name, step_num):
"""
It is used to test the functionality of standard with error in the test case
Arguments:
system_name: Name of the system on which it needs to be run
step_num: It is the step_num in the test case file
Returns:
Returns True
"""
wdesc = "Standard with error"
pNote(wdesc)
key = 'standard_with_error_'+str(step_num)
self.write_to_file(key, system_name)
raise Exception("This is raised in CIregressionActions.standard_with_error")
return False
[docs] def end_of_tc_with_system_name_given(self, system_name, step_num):
"""
It is used to test the functionality of end of tc with system name given in the test case
Arguments:
system_name: Name of the system on which it needs to be run
step_num: It is the step_num in the test case file
Returns:
Returns True
"""
wdesc = "End of testcase with system name given"
pNote(wdesc)
key = 'end_of_tc_with_system_name_given_'+str(step_num)
self.write_to_file(key, system_name)
return True
[docs] def end_of_tc_with_system_name_not_given(self, system_name, step_num):
"""
It is used to test the functionality of end of tc with no system name given in the test case
Arguments:
system_name: Name of the system on which it needs to be run
step_num: It is the step_num in the test case file
Returns:
Returns True
"""
wdesc = "End of testcase with system name not given"
pNote(wdesc)
key = 'end_of_tc_with_system_name_not_given_'+str(step_num)
self.write_to_file(key, system_name)
return True
[docs] def end_of_tc_with_error(self, system_name, step_num):
"""
It is used to test the functionality of end of tc with error given in the test case
Arguments:
system_name: Name of the system on which it needs to be run
step_num: It is the step_num in the test case file
Returns:
Returns True
"""
wdesc = "End of testcase with error"
pNote(wdesc)
key = 'end_of_tc_with_error_'+str(step_num)
self.write_to_file(key, system_name)
raise Exception("This is raised in CIregressionActions.end_of_tc_with_error")
return False
[docs] def compare_hybrid_tc_result(self,input_file):
"""
It takes the input file path which is the expected result and compares with the log file and
returns True if both matches else False and prints the difference to console.
Arguments:
input_file: It takes expected result file path as input
"""
wdesc = "Compares the test case result file with expected result file"
pNote(wdesc)
output_file = data_Utils.get_object_from_datarepository("output_file")
f = open(output_file)
f1 = open(input_file)
output_content = f.readlines()
input_content = f1.readlines()
if output_content == input_content:
return True
output_set = set([tuple([i]) for i in output_content])
input_set = set([tuple([i]) for i in input_content])
output_set_count = len(output_set)
input_set_count = len(input_set)
if output_set_count > input_set_count:
diff = output_set.difference(input_set)
result_content = output_content
else:
diff = input_set.difference(output_set)
result_content = input_content
print "**************The difference between the files is******************"
for j in diff:
s = str(j[0])
index = result_content.index(s)
last_index = result_content.index("****************************\n",index)
start_index = last_index-2
for i in range(start_index-1,last_index+1):
print result_content[i].strip("\n")
return False


Pasta Carbonara | Traditional Pasta From Rome, Italy
by Taste AtlasOriginal article published at TasteAtlas.
Even though carbonara is considered a typical Roman dish today, its origins are quite vague and often disputed. The name is said to have been derived from the carbonari, woodcutters and charcoal-makers who lived in the Appenine mountains northeast of Rome, and who supposedly cooked their pasta over a hardwood charcoal fire and tossed it with eggs and cheese.
Another popular theory claims that carbonara was invented after the liberation of Rome in 1944, when food shortages were so severe that Allied troops distributed bacon and powdered eggs, which the local population would then mix with water to make pasta sauce.
The carbonara we know today is prepared by simply tossing spaghetti with guanciale (cured pork jowl), egg yolks, and Pecorino Romano cheese. Despite its simplicity, this dish remains one of Rome’s favorites, equally popular throughout the country.