ASSIGNMENT: make the FabISP in-circuit programmer
electronics_production/index.htmlThis assignment is about to make the FabISP in-circuit programmer. The FabISP is an in-system programmer for AVR microcontrollers, that allows to program the microcontrollers on other boards using a USB cable. We will be using this programmer through the semester to program the other boards we create.
hello.ISP.44.cad board components traces interiorTable size (LxP): 232.2 x 156.6 mm
Distance from collet tip to table: 232.2 x 156.6 mm
SETTING MACHINE:
- Open fabmodules.org
- Click on Input Format;
- Choose Image (.png) and Upload Image;
- Click on Output Format and choose the machine (Roland Mill (.rml));
- Setting machine: machine SRM-20; Xmin 0; Ymin 0;
- Click on Process and choose (PCB traces(1/64)) or (PCB outline(1/32));
- Change offset to 5 (this is a personal setting);
- Click on Calculate;
- Save.
In order to mill the board we used the Roland MonoFab SRM20 and the Fab Modules. We placed a sacrifical worktop before starting. I secured the board in the milling machine with double sided tape to keep the model from moving in the milling machine and loosing the 0,0 point.
Instructions:
- Turn on the machine for the heating, at least for 20 minutes.
- Open the Fab Modules on a browser (fabmodules.org) and on the new window selected the endmill settings as 1/64".
- Click on the “load" button and selected the file (.png) and then set the machine type as SRM20. Press calculate. Fabmodules generates .rml file.
- When the machine is ready, open Roland Vpanel. Load the .rml file.
- Set the X,Y,Z axes.
- Now you can mill.
- To cut the board a 1/32th n-mill is needed, change the drill tool to the 1/32" on the Fabmodules.org, and repeat the process.
- Open again Roland Vpanel. Load the new .rml file.
- set only Z origin.
- Repeat the same operation for every file.
Components:
. 1 ATTiny 44 microcontroller
. 1 Capacitor 1uF
. 2 Capacitor 10 pF
. 2 Resistor 100 ohm
. 1 Resistor 499 ohm
. 1 Resistor 1K ohm
. 1 Resistor 10K
. one 6 pin header
. 1 USB connector
. 2 jumpers - 0 ohm resistors
. 1 Cystal 20MHz
. two Zener Diode 3.3 V
. one usb mini cable
. one ribbon cable
. two 6 pin connectors
- I used the FabISP labeled board diagram to understand where to place the components on the board, and so soldered the components on the board.
-The first day I had some problems because my soldering iron did not work properly. On the second attempt I managed to finish the PCB.
- We checked the connections with the multimeter to make sure that power and ground were not connected and there was not a short on the power line. I did the "smoke test". We plugged the FabISP into my computer via the mini USB cable. Then I installed the necessary software for AVR programming.
Once verified the operating of my board, I tried and tried to program it with my Mac, but I failed. I asked Ermanno, a guy of FabLab Frosinone, to use his computer, and I manage to do it using Linux.
Solder first the USB and microcontroller and then the rest. Once soldered these two elements, you can say that the job is done.
Carefully check the microcontroller direction, and the polarity of the diodes. Copper is an excellent tool to remove tin in excess.


I am
Dynalyst Engineer
Agenda
- What is AWS re:Invent
- My Concerns about Cloud
- Example of DynamoDB data modeling
- What is Next
“The reason we do this is that this conference is different from most technology conferences. This is not a sales and marketing conference. This is an education and learning conference.
I hope that you learn more about the cloud. You learn a lot from each other and then you take that learning back to your own companies and change your businesses and the customer experiences in your businesses.”
Andy Jassy
SVP, Amazon Web Services
Overview
| Attendees |
Countries |
Sessions |
| 13,500 (8,000) |
63 |
275 |
Cloud Storage
Kinesis, DynamoDB and Redshift
- AWS Deep Dive
- Customer Experiences
Customer Experience Sessions
Example of DynamoDB
Data modeling @Dynalyst
As a distributed database
- Each node not sharing Data
- Each node not sharing Throughput
Bad data distribution (1)
Bad data distribution (2)
Dynalyst Target User
- Low Funnel User
- Mid Funnel User
Low&Mid live in
their own tables
The Benefits
- Better Performance
- Predictable Throughput provisioning
- Reasonable Pricing
What is next
- Scale
- Immutable deployment
- Fault tolerance
Thanks
BY Han Sangwon / Dynalyst


Typing Game¶
This is a set of typing-game.
Install¶
pip install typing-game
USAGE¶
open the command line:
typing-game config.py
Note
conf.py is defined by yourself. About the contents of config.py
, please see here.
an example of conf.py:
from pathlib import Path
__this_dir__ = Path(str(Path('.').parent.absolute())) # do not use the __file__
# TypingDropDown
DROPDOWN_TXT = __this_dir__ / Path('words.txt') # r"C:\\...\words.txt"
# TypingArticle
ARTICLE_DIR = __this_dir__ / Path('article') # The files in which is you want to type.
WIDTH, HEIGHT = (1600, 600)
Note
Each file on the articles, which name should start with a number and use the dot to split the name.
The file extension can be in any format, not limited to text files.
DEMO¶
Contributing¶
If you want to contribute, please use release’s branch as the main branch, The master branch is just purely used to create a GitHub page.
Be sure to write tests for new features. If you have any difficulties, you can ask me or discuss with me. I am glad if you want to join us.
By the way, I’m very friendly!
More¶
See the documentation


Sometimes I forget to save my settings in the cloud, so after the last update, two weeks worth of collecting players and servers on the radar was gone.
I'd like to have an option where you can chose BBlog to automatically save your settings in the cloud at predefined intervals like daily or twice a week.
BrainFooLong
Administrator
We must reduce our server load as much as possible.
Automatic cloud saving will produce much more load as we can handle.
Sorry, rejected.


"""
Convergence acceleration / extrapolation methods for series and
sequences.
References:
Carl M. Bender & Steven A. Orszag, "Advanced Mathematical Methods for
Scientists and Engineers: Asymptotic Methods and Perturbation Theory",
Springer 1999. (Shanks transformation: pp. 368-375, Richardson
extrapolation: pp. 375-377.)
"""
from __future__ import print_function, division
from sympy import factorial, Integer, S
from sympy.core.compatibility import range
[docs]def richardson(A, k, n, N):
"""
Calculate an approximation for lim k->oo A(k) using Richardson
extrapolation with the terms A(n), A(n+1), ..., A(n+N+1).
Choosing N ~= 2*n often gives good results.
A simple example is to calculate exp(1) using the limit definition.
This limit converges slowly; n = 100 only produces two accurate
digits:
>>> from sympy.abc import n
>>> e = (1 + 1/n)**n
>>> print(round(e.subs(n, 100).evalf(), 10))
2.7048138294
Richardson extrapolation with 11 appropriately chosen terms gives
a value that is accurate to the indicated precision:
>>> from sympy import E
>>> from sympy.series.acceleration import richardson
>>> print(round(richardson(e, n, 10, 20).evalf(), 10))
2.7182818285
>>> print(round(E.evalf(), 10))
2.7182818285
Another useful application is to speed up convergence of series.
Computing 100 terms of the zeta(2) series 1/k**2 yields only
two accurate digits:
>>> from sympy.abc import k, n
>>> from sympy import Sum
>>> A = Sum(k**-2, (k, 1, n))
>>> print(round(A.subs(n, 100).evalf(), 10))
1.6349839002
Richardson extrapolation performs much better:
>>> from sympy import pi
>>> print(round(richardson(A, n, 10, 20).evalf(), 10))
1.6449340668
>>> print(round(((pi**2)/6).evalf(), 10)) # Exact value
1.6449340668
"""
s = S.Zero
for j in range(0, N + 1):
s += A.subs(k, Integer(n + j)).doit() * (n + j)**N * (-1)**(j + N) / \
(factorial(j) * factorial(N - j))
return s
[docs]def shanks(A, k, n, m=1):
"""
Calculate an approximation for lim k->oo A(k) using the n-term Shanks
transformation S(A)(n). With m > 1, calculate the m-fold recursive
Shanks transformation S(S(...S(A)...))(n).
The Shanks transformation is useful for summing Taylor series that
converge slowly near a pole or singularity, e.g. for log(2):
>>> from sympy.abc import k, n
>>> from sympy import Sum, Integer
>>> from sympy.series.acceleration import shanks
>>> A = Sum(Integer(-1)**(k+1) / k, (k, 1, n))
>>> print(round(A.subs(n, 100).doit().evalf(), 10))
0.6881721793
>>> print(round(shanks(A, n, 25).evalf(), 10))
0.6931396564
>>> print(round(shanks(A, n, 25, 5).evalf(), 10))
0.6931471806
The correct value is 0.6931471805599453094172321215.
"""
table = [A.subs(k, Integer(j)).doit() for j in range(n + m + 2)]
table2 = table[:]
for i in range(1, m + 1):
for j in range(i, n + m + 1):
x, y, z = table[j - 1], table[j], table[j + 1]
table2[j] = (z*x - y**2) / (z + x - 2*y)
table = table2[:]
return table[n]


I was going in to get my wisdom teeth removed, and I was a little nervous, I'd gone in a week earlier to talk to the surgeon and even watched an informational video to prepare me for the experience. The surgeon said I could bring along some music to listen to while he operated. I was thinking of bringing something that would be engaging yet not too crazy because I wasn't sure what to expect since this would be my first time being exposed to Nitrous Oxide. So I brought along a Beethoven CD which I'd learn to appreciate in a new way after all this was over with...
 At some point during his explanation the gas started to come through the nose mask, the gas smelled sweet yet chemical-ish at the same time. I remember the surgeon saying that his voice may become slightly lower and my body would start to feel tingly. At this point I started laughing, it was incredible, like all my social inhibitions were gone and I diddn't care what he was saying, it was hilarious.
He left the room for a few minutes (not sure for exactly how long due to my sense of time being distorted a bit) and I progessively started to feel the effects of the gas more and more. The first thing I noticed was my body starting to feel distant and tingly, yet I still had control over its movement. My field of vision also shrunk quite a bit, with a dull blackness surrounding the normal areas of my periphery vision. Also the music that was playing through the headphones began to sound VERY interesting, it sounded like I was submerged deeply under water and the music was being played on a boat on the surface and the sounds drifted lazily down to were I was at the bottom of the ocean.
The surgeon and his assistant came in and began the procedure, I completely submitted to them and could feel myself going deeper. They cut and twisted and buzzed, I could feel the vibrations of the tools reverberating through my jaw and my head. Whenever I felt the slightest bit of discomfort sneak up, I breathed in more gas through the mask which gave me a relaxed soothing feeling.
Throughought the surgery I was aware of my body but only vaguely, It was as if my mind had sunk deep into the chair and was looking up through my tube of narrow vision that I had remaining. The music was just the Icing on the cake, Moonlight Sonata was especialy memorable because it just seemed to fit my disconnected, submerged, yet aware and content mood.
I've never used any other sorts of mind-altering drugs before but my experience with N20 in the setting of the operating room was extremely pleasant. I was aware of everything that was happening the whole time yet I was deeply detached. I think I owe my pleasant experience to the mindset that I was in at the time, I completely submitted to the gas and allowed it to enter my lungs and body without panicking at the feeling of something alien in my body. The whole experience was that of deep relaxation and contentment, and I still remember it vividly even though a few months have passed.
To those of you who are expecting to have your wisdom teeth removed, go into the operating room with a calm, aware state of mind and breath the gas as though it was air, completely submitting to the experience, it works out better that way, and you may even enjoy yourself, at least until the gas wears off and you realize whats's happened ;)
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


home
contact us
about us
Sales
Welcome to Pat's Salmon Cookies!
you are welcomed in these hour
from 6:am until 7:pm
our locations .
Seattle
Tokyo
Dubai
Paris
Lima


3D Settings
Home
(current)
Upload Settings
Welcome to 3d Settings
This website is designed to help you upload, backup, and share the settings for your 3d printer
To get started click the upload settings button above


Enter the amount of adsorbate added
Enter the standardization titration value
Enter the weight of adsorbent added and titration values in all 4 flasks respectively


Search
Preparing search index...


Third Lunch Talk with Visitors from BBN
Today we were thrilled to host Bobby Simidcheiva (PhD ‘15) and Vicky Manfredi (PhD ‘09) from Raytheon BBN! They gave a presentation about their work with BBN and held an open Q&A with students after the event.
Raytheon BBN kindly sponsored this lunch. In addition two our two guests and a recruiter, 16 graduate students, 2 undergraduates, and one staff member attended. After the event ended, some of the students who attended graciously stepped outside for a photo in the wind:
Abstract
Have you been wondering about what life is like after school? We are here to help. We are two recent PhD computer science graduates from UMass Amherst now working as researchers at Raytheon BBN Technologies. In this talk, we will give you some background about BBN, share with you how we found jobs there, describe what working at BBN is like, and answer your questions about networking for jobs and transitioning to a non-academic environment.
Raytheon BBN Technologies has been providing advanced technology research and development for over 60 years. From the ARPANET, to the first email, to the first stereo digital mammography system, through the first metro network protected by quantum cryptography, BBN has consistently transitioned advanced research to produce innovative, practical technology solutions for our customers. Today, BBN’s innovations allow for ubiquitous networking and speech understanding in any language or format. BBN scientists and engineers continue to take risks and challenge conventions to create new and fundamentally better solutions.
Bios
Vicky Manfredi is Network Scientist at BBN Technologies. Her current work focuses on designing efficient and secure communication protocols for ad hoc and heterogeneous networks. She also works on problems at the frontier between computer networks and machine learning. Her prior work has looked at the trade-off between incurring some cost (such as control packets or energy) to obtain updated information about the network as conditions change, versus the utility of that information for informing behavior. Vicky received a Ph.D and an M.S. in Computer Science from the University of Massachusetts Amherst, and a B.A. in Computer Science and Neuroscience from Smith College. Prior to BBN, Vicky was a Computing Innovation Fellow at Boston University.
Bobby Simidchieva is a research scientist in the the Distributed Systems group at BBN. Since joining BBN last year, she has primarily been working on quantifying and characterizing cyber security risks. Through modeling distributed systems and the defenses available for deployment, as well as the various attacks that adversaries could execute, we can predict what attacks are feasible and attach metrics such as cost and security to different defenses. In previous work, Bobby has worked on the modeling and analysis of complex human-intensive systems. Her dissertation focused on the explicit specification of variation in families of human-intensive systems to make their modeling more precise and facilitate their subsequent analysis. She recently completed her Ph.D. in Computer Science from the University of Massachusetts Amherst and holds dual B.S. degrees in computer science and computational science from the State University of New York, College at Brockport.


FizzBuzz
Fizzbuzz is a common coding challenge that teaches control flow and use of the modulus operator.
Some FizzBuzz challenges you can find online will have you print out the result for each number from 1 to x. In this challenge, however, we'll save all of the 'Fizzbuzzed' results to a list and return the list at the end of the function.
Lesson objectives
- Understand how to assign variables within a function
- Understand how to use the mouduls operator
- Get comfortable with basic control flow
- Understand how to initialize and add items to a list
Modulus operator
Modulus is a useful mathematical operation available in Python using the %
symbol. It returns the remainder of two numbers when you divide x by y. For example:
10 % 2 # == 0 because 10 is divisible by 2
8 % 3 # == 2 because 2 is the remainder of 8 / 3
Control flow
Control flow is the process by which we tell a program how to make decisions based on certain criteria. If one condition is True
, you instruct the program to do one thing. If it's not, you tell the program to do something else.
Control flow in Python is fairly readable. For example:
x = 2
if x > 2:
print "x is greater than 2"
else:
print "x is less than or equal to 2"
However, Python doesn't limit us to just two options. We can check for multiple conditions in our control flow with the elif
keyword.
x = 2
d
if x > 2:
print "x is greater than 2"
elif x == 2:
print "x equals 2"
elif x == 0:
print "x is zero"
else:
print "x is less than 2"
The else
keyword lets us know that if we've passed through all of our specifically listed conditions and didn't find anything, it should do this. It acts as the "base case" for what to do when no other condition is satisfied.
Features of a list
If you've worked in other programming langauges before, or if you're familiar with different structures in math, a list is Python's name for an array.
-
Python initializes an empty list with two empty square brackets:
[]
- A list can hold any number of items. The items do not need to be the same type.
- Lists are ordered. That means that to access a value inside the list, you need to know what position it occupies in the list.
-
List positions, or "indexes" (or "indicies" - both are correct and people will use them interchangeably), start counting at
0
, not1
.
Challenge Rules:
- The function should accept an integer
- For every integer between 1 and the input the function should save one of four options to an list
- If the integer is divisible by 3, save the word "Fizz" to the list
- If the integer is divisible by 5, save the word "Buzz" to the list
- If the integer is divisible by both 3 and 5, save the word "FizzBuzz" to the list
- If the integer is divisible by neither 3 nor 5, save that integer to the list
- The function should return a list of integers and strings
-
Edge cases
- If the integer input is <= 0, return an emtpy list
Example
fizzbuzz(15) #=> [1, 2, "Fizz", 4, "Buzz", "Fizz", 7, 8, "Fizz", "Buzz", 11, "Fizz", 13, 14, "FizzBuzz"]


DC Ω - Ohm's Law Calculator Voltage (V) Volts (V) Resistance (R) Ohms (Ω) Current (I) Amps (A) Power (P) Watts (W) Reset Help Calc © Copyright Czigler Ferenc All Rights Reserved.
How to use Enter any two variables in the fields. Click Calc button. How to calc Ohm's law: Wikipedia page Electric power: Wikipedia page


public class Timer extends Object
Corresponding to each Timer object is a single background thread that is used to execute all of the timer's tasks, sequentially. Timer tasks should complete quickly. If a timer task takes excessive time to complete, it "hogs" the timer's task execution thread. This can, in turn, delay the execution of subsequent tasks, which may "bunch up" and execute in rapid succession when (and if) the offending task finally completes.
After the last live reference to a Timer object goes away and all outstanding tasks have completed execution, the timer's task execution thread terminates gracefully (and becomes subject to garbage collection). However, this can take arbitrarily long to occur. By default, the task execution thread does not run as a daemon thread, so it is capable of keeping an application from terminating. If a caller wants to terminate a timer's task execution thread rapidly, the caller should invoke the timer's cancel method.
If the timer's task execution thread terminates unexpectedly, for example, because its stop method is invoked, any further attempt to schedule a task on the timer will result in an IllegalStateException, as if the timer's cancel method had been invoked.
This class is thread-safe: multiple threads can share a single Timer object without the need for external synchronization.
This class does not offer real-time guarantees: it schedules tasks using the Object.wait(long) method.
Java 5.0 introduced the java.util.concurrent
package and
one of the concurrency utilities therein is the ScheduledThreadPoolExecutor
which is a thread pool for repeatedly
executing tasks at a given rate or delay. It is effectively a more
versatile replacement for the Timer
/TimerTask
combination, as it allows multiple service threads, accepts various
time units, and doesn't require subclassing TimerTask
(just
implement Runnable
). Configuring ScheduledThreadPoolExecutor
with one thread makes it equivalent to
Timer
.
Implementation note: This class scales to large numbers of concurrently scheduled tasks (thousands should present no problem). Internally, it uses a binary heap to represent its task queue, so the cost to schedule a task is O(log n), where n is the number of concurrently scheduled tasks.
Implementation note: All constructors start a timer thread.
TimerTask
,
Object.wait(long)
| Constructor and Description |
|---|
Timer()
Creates a new timer.
|
Timer(boolean isDaemon)
Creates a new timer whose associated thread may be specified to
run as a daemon.
|
Timer(String name)
Creates a new timer whose associated thread has the specified name.
|
Timer(String name,
boolean isDaemon)
Creates a new timer whose associated thread has the specified name,
and may be specified to
run as a daemon.
|
| Modifier and Type | Method and Description |
|---|---|
void |
cancel()
Terminates this timer, discarding any currently scheduled tasks.
|
int |
purge()
Removes all cancelled tasks from this timer's task queue.
|
void |
schedule(TimerTask task,
Date time)
Schedules the specified task for execution at the specified time.
|
void |
schedule(TimerTask task,
Date firstTime,
long period)
Schedules the specified task for repeated fixed-delay execution,
beginning at the specified time.
|
void |
schedule(TimerTask task,
long delay)
Schedules the specified task for execution after the specified delay.
|
void |
schedule(TimerTask task,
long delay,
long period)
Schedules the specified task for repeated fixed-delay execution,
beginning after the specified delay.
|
void |
scheduleAtFixedRate(TimerTask task,
Date firstTime,
long period)
Schedules the specified task for repeated fixed-rate execution,
beginning at the specified time.
|
void |
scheduleAtFixedRate(TimerTask task,
long delay,
long period)
Schedules the specified task for repeated fixed-rate execution,
beginning after the specified delay.
|
public Timer()
public Timer(boolean isDaemon)
isDaemon
- true if the associated thread should run as a daemon.public Timer(String name)
name
- the name of the associated threadNullPointerException
- if name
is nullpublic Timer(String name, boolean isDaemon)
name
- the name of the associated threadisDaemon
- true if the associated thread should run as a daemonNullPointerException
- if name
is nullpublic void schedule(TimerTask task, long delay)
task
- task to be scheduled.delay
- delay in milliseconds before task is to be executed.IllegalArgumentException
- if delay is negative, or
delay + System.currentTimeMillis() is negative.IllegalStateException
- if task was already scheduled or
cancelled, timer was cancelled, or timer thread terminated.NullPointerException
- if task
is nullpublic void schedule(TimerTask task, Date time)
task
- task to be scheduled.time
- time at which task is to be executed.IllegalArgumentException
- if time.getTime() is negative.IllegalStateException
- if task was already scheduled or
cancelled, timer was cancelled, or timer thread terminated.NullPointerException
- if task
or time
is nullpublic void schedule(TimerTask task, long delay, long period)
In fixed-delay execution, each execution is scheduled relative to the actual execution time of the previous execution. If an execution is delayed for any reason (such as garbage collection or other background activity), subsequent executions will be delayed as well. In the long run, the frequency of execution will generally be slightly lower than the reciprocal of the specified period (assuming the system clock underlying Object.wait(long) is accurate).
Fixed-delay execution is appropriate for recurring activities that require "smoothness." In other words, it is appropriate for activities where it is more important to keep the frequency accurate in the short run than in the long run. This includes most animation tasks, such as blinking a cursor at regular intervals. It also includes tasks wherein regular activity is performed in response to human input, such as automatically repeating a character as long as a key is held down.
task
- task to be scheduled.delay
- delay in milliseconds before task is to be executed.period
- time in milliseconds between successive task executions.IllegalArgumentException
- if delay < 0
, or
delay + System.currentTimeMillis() < 0
, or
period <= 0
IllegalStateException
- if task was already scheduled or
cancelled, timer was cancelled, or timer thread terminated.NullPointerException
- if task
is nullpublic void schedule(TimerTask task, Date firstTime, long period)
In fixed-delay execution, each execution is scheduled relative to the actual execution time of the previous execution. If an execution is delayed for any reason (such as garbage collection or other background activity), subsequent executions will be delayed as well. In the long run, the frequency of execution will generally be slightly lower than the reciprocal of the specified period (assuming the system clock underlying Object.wait(long) is accurate). As a consequence of the above, if the scheduled first time is in the past, it is scheduled for immediate execution.
Fixed-delay execution is appropriate for recurring activities that require "smoothness." In other words, it is appropriate for activities where it is more important to keep the frequency accurate in the short run than in the long run. This includes most animation tasks, such as blinking a cursor at regular intervals. It also includes tasks wherein regular activity is performed in response to human input, such as automatically repeating a character as long as a key is held down.
task
- task to be scheduled.firstTime
- First time at which task is to be executed.period
- time in milliseconds between successive task executions.IllegalArgumentException
- if firstTime.getTime() < 0
, or
period <= 0
IllegalStateException
- if task was already scheduled or
cancelled, timer was cancelled, or timer thread terminated.NullPointerException
- if task
or firstTime
is nullpublic void scheduleAtFixedRate(TimerTask task, long delay, long period)
In fixed-rate execution, each execution is scheduled relative to the scheduled execution time of the initial execution. If an execution is delayed for any reason (such as garbage collection or other background activity), two or more executions will occur in rapid succession to "catch up." In the long run, the frequency of execution will be exactly the reciprocal of the specified period (assuming the system clock underlying Object.wait(long) is accurate).
Fixed-rate execution is appropriate for recurring activities that are sensitive to absolute time, such as ringing a chime every hour on the hour, or running scheduled maintenance every day at a particular time. It is also appropriate for recurring activities where the total time to perform a fixed number of executions is important, such as a countdown timer that ticks once every second for ten seconds. Finally, fixed-rate execution is appropriate for scheduling multiple repeating timer tasks that must remain synchronized with respect to one another.
task
- task to be scheduled.delay
- delay in milliseconds before task is to be executed.period
- time in milliseconds between successive task executions.IllegalArgumentException
- if delay < 0
, or
delay + System.currentTimeMillis() < 0
, or
period <= 0
IllegalStateException
- if task was already scheduled or
cancelled, timer was cancelled, or timer thread terminated.NullPointerException
- if task
is nullpublic void scheduleAtFixedRate(TimerTask task, Date firstTime, long period)
In fixed-rate execution, each execution is scheduled relative to the scheduled execution time of the initial execution. If an execution is delayed for any reason (such as garbage collection or other background activity), two or more executions will occur in rapid succession to "catch up." In the long run, the frequency of execution will be exactly the reciprocal of the specified period (assuming the system clock underlying Object.wait(long) is accurate). As a consequence of the above, if the scheduled first time is in the past, then any "missed" executions will be scheduled for immediate "catch up" execution.
Fixed-rate execution is appropriate for recurring activities that are sensitive to absolute time, such as ringing a chime every hour on the hour, or running scheduled maintenance every day at a particular time. It is also appropriate for recurring activities where the total time to perform a fixed number of executions is important, such as a countdown timer that ticks once every second for ten seconds. Finally, fixed-rate execution is appropriate for scheduling multiple repeating timer tasks that must remain synchronized with respect to one another.
task
- task to be scheduled.firstTime
- First time at which task is to be executed.period
- time in milliseconds between successive task executions.IllegalArgumentException
- if firstTime.getTime() < 0
or
period <= 0
IllegalStateException
- if task was already scheduled or
cancelled, timer was cancelled, or timer thread terminated.NullPointerException
- if task
or firstTime
is nullpublic void cancel()
Note that calling this method from within the run method of a timer task that was invoked by this timer absolutely guarantees that the ongoing task execution is the last task execution that will ever be performed by this timer.
This method may be called repeatedly; the second and subsequent calls have no effect.
public int purge()
Most programs will have no need to call this method. It is designed for use by the rare application that cancels a large number of tasks. Calling this method trades time for space: the runtime of the method may be proportional to n + c log n, where n is the number of tasks in the queue and c is the number of cancelled tasks.
Note that it is permissible to call this method from within a a task scheduled on this timer.
Dracula Javadoc Sample, Made with Allan Im.


The paper focuses on the three dominant theoretical paradigms for understanding monsoon precipitation and its changes: convective quasi-equilibrium (CQE), the moist static energy (MSE) budget, and monsoons as shifts in the Intertropical Convergence Zone (ITCZ). [This alphabet soup of semi-rhyming acronyms led to an original cheeky title of “CQE, MSE, ITCZ, or all three?” I thank the reviewers (Mike Byrne and one anonymous) for convincing me that was a bit /too/ cheeky.]
The paper also discusses challenges the community must surmount in inferring monsoon rainfall behavior in Earth’s past via paleoclimate proxy records. It concludes on a positive note, emphasizing the ability of theory to directly inform model development efforts and promoting recent advances in how theory and modeling results can be most effectively communicated to societal stakeholders.


Half the container width: in this case the body tag
Fourth width, a Third pushed but nothing happening
Half width, a Third pushed working
Half width, a Third pushed relative
Half width, a Third pushed absolute


Homework78 : FFT
Now you build a learner. An FFT tree which, as you recall contains nodes tiwh two kids:
- One is an exit node and has the form `if x > 7 then y'.
- Note that the "arity" of the exit test is one.
- That is, we test for
x>7
and notx>7 AND y<3
.
- The other is
other
. Any data that fails the exit test goes intoother
(and FFT trees extended by recursing on that data). - FFT's are built to a maximum depth of, say,
d=4
. - FTT's run over discrete and continuous attributes
- For discrete attributes, the exit test will be
x=value
- For contuous attributes, the exit test will be
x<=10
orx>10
.- And just to keep it simple, we'll only try to break numerics at median values
- For discrete attributes, the exit test will be
The core algorithm is very simple:
- Divide all independent colums into
cuts
. - Sort all
cuts
by the average score of the dependent variable seen in eachcut
. - Split the data into (a) that which falls into the best
cut
and (b)other
. - Print out the best
cut
as an exit rule - Recurse on
other
.
Here's what I get whet I take
auto and run it through
dom
and then `fft
. The numbers at the end of each line is the mean value of the depedent
value in each cut
. Note that the best cut we see gets us to examples with an average
dom
score of 74.
if origin is 3 ==> 74
else %cylinders is 4 ==> 70
else %cylinders is 5 ==> 65
else %cylinders is 6 ==> 39
Here's another run using the same data but this time I discretize the numerics using unsuper. Now we get much better ressults (note our best gets us to 92). So the lesson here is that median cuts (done above) can be much worse that unsupervised discretized cuts (done below).
if horsepower is ..65 ==> 92
else horsepower is 66..69 ==> 86
else displacement is 97.5..101 ==> 82
else displacement is 85..91 ==> 79
What to hand in
The usual drill. A new sub-directory. Python source coe. and Example out .txt
file.
Task7: FFT, part1 (due this week).
In task1, do not worry about unsupervised descritization or building the tree. That is next week.
Using the code at fft, generate the cuts and sort them by their mean goal score. Print out what you would use for the first cut of the first part of the FFT tree.
-
For weatherLong, the best cut I find is
outlook=overcast
which has a mean dom score of 53 -
For auto, the best cut I find (without unsuper.s
origin=3
with an average dom score of 74.
Don't worry if you do not exactly my best cuts. Near enough will do.
Task8: FFT, part2 (due this week).
Add in unsupervised descritization. And build the FFT trees recursively (where at each level, find the new best cuts).


Sanitation drive to be taken up in all wards
50% of staff from all GHMC wings will be roped in, says Mayor
by Special CorrespondentThe GHMC would take up 360 degree sanitation work in all the 150 wards in the coming days, said Mayor Bonthu Ram Mohan, and appealed to the citizens, resident welfare associations, self help groups and NGOs to participate in the programme.
He addressed the representatives of RWAs, and basti committees on Monday and said though regular sanitation work was on, the corporation proposed to intensify the city clean-up by organising a special sanitation drive.
For the special drive, 50% of the staff from Engineering, Town Planning, Entomology, Urban Biodiversity, Veterinary, Urban Community Development and Enforcement wings would be roped in.
Dates for the drive would be announced in future, and it would go on for two to three days in each ward. It would include work such as cleaning the main roads, filling of pot holes, removing debris and construction waste, weed removal in open places, and removal of solid waste material from manholes, drains and nalas.
Clearing the plastic covers, replacing of manhole covers, repair of sewerage lines, removing debris near transformers, repair of footpaths and dividers, fogging and anti-larval operations, checking street dog menace, and others too would be part of the drive.
Besides, inspections would be conducted to ensure hygiene at various roadside eateries and hotels, a press statement said.


|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object org.apache.xalan.transformer.KeyTable
public class KeyTable
Table of element keys, keyed by document node. An instance of this class is keyed by a Document node that should be matched with the root of the current context.
| Field Summary | |
|---|---|
private int |
m_docKey
The document key. |
private java.util.Vector |
m_keyDeclarations
Vector of KeyDeclaration instances holding the key declarations. |
private XNodeSet |
m_keyNodes
The main iterator that will walk through the source tree for this key. |
private java.util.Hashtable |
m_refsTable
Hold a cache of key() function result for each ref. |
| Constructor Summary | |
|---|---|
KeyTable(int doc,
PrefixResolver nscontext,
QName name,
java.util.Vector keyDeclarations,
XPathContext xctxt)
Build a keys table. |
| Method Summary | |
|---|---|
private void |
addValueInRefsTable(XPathContext xctxt,
XMLString ref,
int node)
Add an association between a ref and a node in the m_refsTable. |
int |
getDocKey()
Get the document root matching this key. |
private java.util.Vector |
getKeyDeclarations()
|
(package private) KeyIterator |
getKeyIterator()
|
QName |
getKeyTableName()
Get Key Name for this KeyTable |
XNodeSet |
getNodeSetDTMByKey(QName name,
XMLString ref)
Given a valid element key, return the corresponding node list. |
private java.util.Hashtable |
getRefsTable()
|
| Methods inherited from class java.lang.Object |
|---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Field Detail |
|---|
private int m_docKey
private java.util.Vector m_keyDeclarations
private java.util.Hashtable m_refsTable
private XNodeSet m_keyNodes
| Constructor Detail |
|---|
public KeyTable(int doc, PrefixResolver nscontext, QName name, java.util.Vector keyDeclarations, XPathContext xctxt) throws javax.xml.transform.TransformerException
doc
- The owner document key.nscontext
- The stylesheet's namespace context.name
- The key namekeyDeclarations
- The stylesheet's xsl:key declarations.
javax.xml.transform.TransformerException
| Method Detail |
|---|
public int getDocKey()
KeyIterator getKeyIterator()
public XNodeSet getNodeSetDTMByKey(QName name, XMLString ref)
name
- The name of the key, which must match the 'name' attribute on xsl:key.ref
- The value that must match the value found by the 'match' attribute on xsl:key.
name
and the reference ref
. If no node is referenced by this key, an empty node set is returned.public QName getKeyTableName()
private java.util.Vector getKeyDeclarations()
private java.util.Hashtable getRefsTable()
private void addValueInRefsTable(XPathContext xctxt, XMLString ref, int node)
xctxt
- XPath contextref
- the value of the use clause of the current key for the given nodenode
- the node to reference
|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


This guide references the following code systems.
|
Name
|
Definition
|
| FHIR CompositionAttestationMode |
http://hl7.org/fhir/composition-attestation-mode The way in which a person authenticated a composition. |
| LOINC |
|
| HL7ActClass |
urn:oid:2.16.840.1.113883.5.6 |
| DCM |
urn:oid:1.2.840.10<IP_ADDRESS> DICOM |


This is the Bus Mall App. Please click on the products that you would be most interested in buying. After 5 selections you can view the results.
clear local storage
reset


St. Martin De Porres catholic Church, Atonsu-Kumasi welcomes you
Meet us
Let us not neglect our meeting together, as some people do, but encourage one another, especially now that the day of his return is drawing near (Hebrews 10:25)
Join us
For where two or more have gathered together in My name, i am there in their midst. (Matthew 18:20)
Give unto the Lord
For God loves a cheerful giver. (2nd Corithians 9:7b)


It supports the development of this theme via one of the good deeds that can help to improve it!
I'm open to any form of help! If you have an idea to help put it immediately in place, or if you need to contact me to implement it write to lantoniotrento[at]gmail.com


The development of AI for games such as Go, chess, and poker has made great strides in recent years, with AI now able to defeat some of the strongest human players. Relatively little work has been done on more modern games, which frequently feature the release of additional content and hidden information. Following the approach of the draftsim model, this problem can be approached by making "easy" decisions with a rules based model and answering the "hard" questions with learning methods.
An application of this approach is applied to Dominion, a popular and pioneering deckbuilding game released by Donald X. Vaccarino. The game revolves around building a deck containing action and treasure cards, which do useful things, and victory cards, which score points at the end of the game. A number of dominion simulators have been developed, however, these tools focus primarily on simple money strategies as opposed to the complex engine decks with flourish at higher levels of play.
I am currently working with a team of five Caltech graduate students on building more sophisticated AI for dominion, focused on blending rules-based and learning based decisions. I bring substantial competitive experience to the team as the top ranked dominion player, as well as winning the Dominion Online Championship.
An example of the interface for human-bot games is shown below:
Dominion interface for human-bot games implemented using the pygame python package.
A number of bots have been implemented in the pygame framework:
When purchasing cards, village bot seeks to maximize payload, defined as a function of coins, buys, cards gained, attacks played, cards trashed, and VP gained. The value of trashing junk cards increases early in the game, and the value of VP gaining is increased later in the game, as opponents begin to threaten to end the game. To simplify the payload computation, the mean field approximation is made to describe the distribution of additional +Cards, +Actions, and payload within a deck.
Decisions on how to play action cards are handled with a simple set of heuristics. Work has begun on implementing methods to determine the impact of individual buy and play decisions using Monte Carlo tree search and to examine the effect of overall model parameters on winrate using genetic algorithms. As work continues, it will be interesting to explore the range of effectiveness of rules-based and learning methods for dominion and to find the combination of methods best suited for practical application.


By Saskia | May 21, 2019
changepoint
: changes in mean and variance of time seriesbcp
: changes in mean; Bayesian approachstrucchange
: changes in (time series) regression modelsegmented
: changes in regression (does not have to be time series data)tree
: classication
Detection performance under different scenarios
# Loading packages
library(changepoint)
library(bcp)
library(strucchange)
library(segmented)
library(tree)
1 change in mean
Real data: Nile dataset
The Nile dataset comes with the R dataset
package and represents measurements of the annual flow (in unit 108 m3) of the river Nile at Aswan (formerly Assuan), between 1871 and 1970. Around 1898, the annual flow dropped greatly from circa 1100 to 8001. We will test now whether this shift will be detected by all 5 methods.
data(Nile)
str(Nile)
## Time-Series [1:100] from 1871 to 1970: 1120 1160 963 1210 1160 1160 813 1230 1370 1140 ...
plot(Nile)
changepoint
Looking for 1 changepoint, using default setting
cpt_nile1 <- cpt.mean(Nile, method = "AMOC")
cpt_nile1@cpts
## [1] 28 100
Looking for multiple changepoints
cpt.mean(Nile, method = "PELT", Q = 10)
## Class 'cpt' : Changepoint Object
## ~~ : S4 class containing 12 slots with names
## cpttype date version data.set method test.stat pen.type pen.value minseglen cpts ncpts.max param.est
##
## Created on : Mon Apr 23 00:37:43 2018
##
## summary(.) :
## ----------
## Created Using changepoint version 2.2.2
## Changepoint type : Change in mean
## Method of analysis : PELT
## Test Statistic : Normal
## Type of penalty : MBIC with value, 13.81551
## Minimum Segment Length : 1
## Maximum no. of cpts : Inf
## Number of changepoints: 94
cpt.mean(Nile, method = "PELT", penalty = "CROPS", pen.value = c(1,25))
## [1] "Maximum number of runs of algorithm = 6"
## [1] "Completed runs = 2"
## [1] "Completed runs = 3"
## [1] "Completed runs = 5"
## Class 'cpt' : Changepoint Object
## ~~ : S4 class containing 14 slots with names
## cpts.full pen.value.full data.set cpttype method test.stat pen.type pen.value minseglen cpts ncpts.max param.est date version
##
## Created on : Mon Apr 23 00:37:43 2018
##
## summary(.) :
## ----------
## Created Using changepoint version 2.2.2
## Changepoint type : Change in mean
## Method of analysis : PELT
## Test Statistic : Normal
## Type of penalty : CROPS with value, 1 25
## Minimum Segment Length : 1
## Maximum no. of cpts : Inf
## Changepoint Locations :
## Range of segmentations:
## [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10] [,11] [,12] [,13]
## [1,] 1 2 3 4 6 7 8 9 10 11 12 13 14
## [2,] 1 2 3 4 6 7 8 9 10 11 12 13 14
## [3,] 1 2 3 4 6 7 8 9 10 11 12 13 14
## [4,] 1 2 3 4 6 7 8 9 10 11 12 13 14
## [,14] [,15] [,16] [,17] [,18] [,19] [,20] [,21] [,22] [,23] [,24]
## [1,] 15 16 17 18 19 20 21 22 23 24 25
## [2,] 15 16 17 18 19 20 21 22 23 24 25
## [3,] 15 16 17 18 19 20 21 22 23 24 25
## [4,] 15 16 17 18 19 20 21 22 23 24 25
## [,25] [,26] [,27] [,28] [,29] [,30] [,31] [,32] [,33] [,34] [,35]
## [1,] 26 27 28 29 30 31 32 33 34 35 36
## [2,] 26 27 28 29 30 31 32 33 34 35 36
## [3,] 26 27 28 29 30 31 32 33 34 35 36
## [4,] 26 27 28 29 30 31 32 33 34 35 36
## [,36] [,37] [,38] [,39] [,40] [,41] [,42] [,43] [,44] [,45] [,46]
## [1,] 37 38 39 40 41 42 43 44 45 46 47
## [2,] 37 38 39 40 41 42 43 44 45 46 47
## [3,] 37 38 39 40 41 42 43 44 45 46 47
## [4,] 37 38 39 40 41 42 43 44 45 46 47
## [,47] [,48] [,49] [,50] [,51] [,52] [,53] [,54] [,55] [,56] [,57]
## [1,] 48 49 50 51 52 53 54 55 56 57 58
## [2,] 48 49 50 51 52 54 55 56 57 58 59
## [3,] 48 49 50 51 52 54 55 56 57 58 59
## [4,] 48 49 50 51 52 54 55 56 57 58 59
## [,58] [,59] [,60] [,61] [,62] [,63] [,64] [,65] [,66] [,67] [,68]
## [1,] 59 60 61 62 63 64 65 66 67 68 69
## [2,] 60 61 62 63 64 65 66 67 68 69 70
## [3,] 60 61 62 63 64 65 66 67 68 69 70
## [4,] 60 61 62 63 64 65 66 67 68 69 70
## [,69] [,70] [,71] [,72] [,73] [,74] [,75] [,76] [,77] [,78] [,79]
## [1,] 70 71 72 73 74 75 76 77 78 79 80
## [2,] 71 72 73 74 75 76 77 78 79 80 81
## [3,] 71 72 73 74 75 76 77 78 79 80 81
## [4,] 71 72 73 74 75 76 77 78 79 80 82
## [,80] [,81] [,82] [,83] [,84] [,85] [,86] [,87] [,88] [,89] [,90]
## [1,] 81 82 83 84 85 86 87 88 89 90 91
## [2,] 82 83 84 85 86 87 88 89 90 91 92
## [3,] 82 83 84 85 86 87 88 89 90 91 92
## [4,] 83 84 85 86 87 88 89 90 91 93 94
## [,91] [,92] [,93] [,94] [,95] [,96] [,97] [,98]
## [1,] 92 93 94 95 96 97 98 99
## [2,] 93 94 95 96 97 98 99 NA
## [3,] 93 94 95 96 97 99 NA NA
## [4,] 95 96 97 99 NA NA NA NA
##
## For penalty values: 1 2 8 12.5
Too many changepoints detected (same when settings changed to “SegNeigh” or “BinSeg” method)
bcp
x <- Nile
bcp_x <- bcp(x, return.mcmc = TRUE)
plot(bcp_x)
Let’s see at which time step the posterior probability of a change (?) is above 70%:
bcp_sum <- as.data.frame(summary(bcp_x))
##
## Bayesian Change Point (bcp) summary:
##
##
## Probability of a change in mean and posterior means:
##
## Probability X1
## 1 0.024 1087.4
## 2 0.012 1087.1
## 3 0.010 1086.6
## 4 0.012 1086.8
## 5 0.014 1086.7
## 6 0.014 1086.1
## 7 0.016 1084.0
## 8 0.020 1087.3
## 9 0.040 1090.0
## 10 0.048 1084.0
## 11 0.028 1078.3
## 12 0.010 1075.8
## 13 0.020 1075.8
## 14 0.016 1075.1
## 15 0.008 1074.2
## 16 0.020 1073.8
## 17 0.038 1074.6
## 18 0.036 1069.8
## 19 0.084 1074.3
## 20 0.036 1086.3
## 21 0.060 1090.1
## 22 0.024 1097.6
## 23 0.026 1099.7
## 24 0.016 1101.6
## 25 0.010 1102.4
## 26 0.074 1102.2
## 27 0.014 1086.3
## 28 0.886 1084.6
## 29 0.046 858.2
## 30 0.024 851.4
## 31 0.018 848.9
## 32 0.020 847.7
## 33 0.008 848.7
## 34 0.010 848.9
## 35 0.020 848.7
## 36 0.012 850.1
## 37 0.044 849.8
## 38 0.016 855.6
## 39 0.030 856.9
## 40 0.030 855.5
## 41 0.072 849.9
## 42 0.034 836.1
## 43 0.054 830.1
## 44 0.026 840.3
## 45 0.082 843.1
## 46 0.028 863.0
## 47 0.046 861.6
## 48 0.024 852.2
## 49 0.018 850.7
## 50 0.012 850.0
## 51 0.014 850.0
## 52 0.010 850.2
## 53 0.016 850.2
## 54 0.008 850.1
## 55 0.008 850.0
## 56 0.018 850.1
## 57 0.014 850.4
## 58 0.024 850.8
## 59 0.012 851.7
## 60 0.014 851.7
## 61 0.012 852.1
## 62 0.016 852.7
## 63 0.024 853.4
## 64 0.014 854.5
## 65 0.016 855.0
## 66 0.024 854.1
## 67 0.016 853.1
## 68 0.018 853.0
## 69 0.020 851.6
## 70 0.018 849.9
## 71 0.022 849.8
## 72 0.022 851.0
## 73 0.020 852.1
## 74 0.018 852.9
## 75 0.032 854.3
## 76 0.016 856.6
## 77 0.016 857.2
## 78 0.020 857.8
## 79 0.020 858.1
## 80 0.022 858.6
## 81 0.016 859.1
## 82 0.036 860.0
## 83 0.060 862.6
## 84 0.016 868.1
## 85 0.020 868.6
## 86 0.008 869.3
## 87 0.012 868.8
## 88 0.014 869.5
## 89 0.018 870.0
## 90 0.018 870.3
## 91 0.012 871.0
## 92 0.006 871.6
## 93 0.024 871.9
## 94 0.044 874.4
## 95 0.068 867.6
## 96 0.034 857.5
## 97 0.054 854.5
## 98 0.022 845.9
## 99 0.014 843.3
## 100 NA 842.1
bcp_sum$id <- 1:length(x)
(sel <- bcp_sum[which(bcp_x$posterior.prob > 0.7), ])
## Probability X1 id
## 28 0.886 1084.559 28
time(x)[sel$id] # Year
## [1] 1898
strucchange
ocus_nile <- efp(Nile ~ 1, type = "OLS-CUSUM")
op <- par(mfrow = c(1,2))
plot(ocus_nile)
plot(ocus_nile, alpha = 0.01, alt.boundary = TRUE)
par(op)
Process has a peak around 1900 which exceeds the boundaries and hence indicates a clear structural shift at that time.
Calculate corresponding test statistic for structural change:
sctest(ocus_nile)
##
## OLS-based CUSUM test
##
## data: ocus_nile
## S0 = 2.9518, p-value = 5.409e-08
F test:
fs_nile <- Fstats(Nile ~ 1)
plot(fs_nile)
Same conclusion from tests based on F statistics.
Estimate breakpoint from breakpoints()
function:
bp_nile <- breakpoints(Nile ~ 1)
bp_nile
##
## Optimal 2-segment partition:
##
## Call:
## breakpoints.formula(formula = Nile ~ 1)
##
## Breakpoints at observation number:
## 28
##
## Corresponding to breakdates:
## 1898
summary(bp_nile)
##
## Optimal (m+1)-segment partition:
##
## Call:
## breakpoints.formula(formula = Nile ~ 1)
##
## Breakpoints at observation number:
##
## m = 1 28
## m = 2 28 83
## m = 3 28 68 83
## m = 4 28 45 68 83
## m = 5 15 30 45 68 83
##
## Corresponding to breakdates:
##
## m = 1 1898
## m = 2 1898 1953
## m = 3 1898 1938 1953
## m = 4 1898 1915 1938 1953
## m = 5 1885 1900 1915 1938 1953
##
## Fit:
##
## m 0 1 2 3 4 5
## RSS 2835157 1597457 1552924 1538097 1507888 1659994
## BIC 1318 1270 1276 1285 1292 1311
To check for more breaks the breakpoint()
function can be also applied to breakpoints object
breakpoints(bp_nile, breaks = 2)
##
## Optimal 3-segment partition:
##
## Call:
## breakpoints.breakpointsfull(obj = bp_nile, breaks = 2)
##
## Breakpoints at observation number:
## 28 83
##
## Corresponding to breakdates:
## 1898 1953
breakpoints(bp_nile, breaks = 3)
##
## Optimal 4-segment partition:
##
## Call:
## breakpoints.breakpointsfull(obj = bp_nile, breaks = 3)
##
## Breakpoints at observation number:
## 28 68 83
##
## Corresponding to breakdates:
## 1898 1938 1953
BIC estimates for different numbers of breakpoint
plot(bp_nile)
The BIC also chooses one breakpoint.
To get the optimal number numerically, here is a solution:
# get best model
opt_bpts <- function(x) {
#x = bpts_sum$RSS["BIC",]
n <- length(x)
lowest <- vector("logical", length = n-1)
lowest[1] <- FALSE
for (i in 2:n) {
lowest[i] <- x[i] < x[i-1] & x[i] < x[i+1]
}
out <- as.integer(names(x)[lowest])
return(out)
}
bpts_sum <- summary(bp_nile)
opt_brks <- opt_bpts(bpts_sum$RSS["BIC",])
opt_brks
## [1] 1
To visualize the breakpoints in the time series plot with confidence intervals:
ci_nile <- confint(bp_nile, breaks = opt_brks)
plot(Nile)
lines(ci_nile)
Compare the null model with the model with 1 breakpoint:
fm0 <- lm(Nile ~ 1)
coef(fm0)
## (Intercept)
## 919.35
nile_fac <- breakfactor(bp_nile, breaks = 1)
fm1 <- lm(Nile ~ nile_fac - 1)
coef(fm1)
## nile_facsegment1 nile_facsegment2
## 1097.7500 849.9722
plot(Nile)
lines(ts(fitted(fm0), start = 1871), col = 3)
lines(ts(fitted(fm1), start = 1871), col = 4)
lines(bp_nile)
segmented
With this method, the number of breakpoints have to be set as starting point apriori:
Nile_df <- data.frame(Nile = as.numeric(Nile), Year = 1871:1970)
seg_nile <- segmented(lm(Nile ~ 1, data = Nile_df), ~ Year,
psi = list(Year = c(1900))) # using 1900 as starting value
summary(seg_nile)
##
## ***Regression Model with Segmented Relationship(s)***
##
## Call:
## segmented.lm(obj = lm(Nile ~ 1, data = Nile_df), seg.Z = ~Year,
## psi = list(Year = c(1900)))
##
## Estimated Break-Point(s):
## Est. St.Err
## 1876.245 25.454
##
## Meaningful coefficients of the linear terms:
## Estimate Std. Error t value Pr(>|t|)
## (Intercept) 1040.412 61.866 16.817 <2e-16 ***
## U1.Year -2.725 0.576 -4.731 NA
## ---
## Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
##
## Residual standard error: 151.5 on 97 degrees of freedom
## Multiple R-Squared: 0.2143, Adjusted R-squared: 0.1981
##
## Convergence attained in 1 iterations with relative change -0.2351176
slope(seg_nile)
## $Year
## Est. St.Err. t value CI(95%).l CI(95%).u
## slope1 0.0000 NA NA NA NA
## slope2 -2.7254 0.57604 -4.7313 -3.8687 -1.5821
plot(Nile ~ Year, data = Nile_df, type = "l")
plot(seg_nile, add=T)
lines(seg_nile,col='red')
Segmented does not detect any change. It is not devised for this kind of step changes.
tree
Nile_df <- data.frame(Nile = as.numeric(Nile), Year = 1871:1970)
tree_nile <- tree(Nile ~ Year, data = Nile_df)
summary(tree_nile)
##
## Regression tree:
## tree(formula = Nile ~ Year, data = Nile_df)
## Number of terminal nodes: 6
## Residual mean deviance: 13750 = 1293000 / 94
## Distribution of residuals:
## Min. 1st Qu. Median Mean 3rd Qu. Max.
## -380.100 -62.160 -3.645 0.000 54.840 283.900
plot(tree_nile)
text(tree_nile, pretty = 0)
Artificial data
set.seed(1)
# Normal distributed data with a single change in mean (at x = 25-26)
df <- data.frame(
x = 1:50,
z = c(rnorm(25,0,1), rnorm(25,5,1))
)
plot(df$x, df$z, type = 'l', xlab = '', ylab = '')
lines(x = 1:25, y = rep(0,25), col = 'red', lwd = 3)
lines(x=26:50, y = rep(5,25), col = 'red', lwd = 3)
changepoint
Testing for 1 changepoint
## Created Using changepoint version 2.2.2
## Changepoint type : Change in mean
## Method of analysis : AMOC
## Test Statistic : Normal
## Type of penalty : MBIC with value, 11.73607
## Minimum Segment Length : 1
## Maximum no. of cpts : 1
## Changepoint Locations : 25
Testing for several using PELT method and AIC penalty:
## Class 'cpt' : Changepoint Object
## ~~ : S4 class containing 12 slots with names
## cpttype date version data.set method test.stat pen.type pen.value minseglen cpts ncpts.max param.est
##
## Created on : Mon Apr 23 00:37:43 2018
##
## summary(.) :
## ----------
## Created Using changepoint version 2.2.2
## Changepoint type : Change in mean
## Method of analysis : PELT
## Test Statistic : Normal
## Type of penalty : AIC with value, 4
## Minimum Segment Length : 1
## Maximum no. of cpts : Inf
## Changepoint Locations : 25
Also just 1 changepoint detected at x = 25.
Testing for several using PELT method and CROPS penalty:
## [1] "Maximum number of runs of algorithm = 13"
## [1] "Completed runs = 2"
## [1] "Completed runs = 3"
## [1] "Completed runs = 5"
## [1] "Completed runs = 9"
## [1] "Completed runs = 11"
## [1] "Completed runs = 12"
## Created Using changepoint version 2.2.2
## Changepoint type : Change in mean
## Method of analysis : PELT
## Test Statistic : Normal
## Type of penalty : CROPS with value, 1 25
## Minimum Segment Length : 1
## Maximum no. of cpts : Inf
## Changepoint Locations :
## Number of segmentations recorded: 7 with between 1 and 12 changepoints.
## Penalty value ranges from: 1 to 3.023723
In the following order strong changepoints detected:
cpts_ord(cpts.full(cpt2))[1:5]
## [1] 25 13 14 23 24
5 changepoints detected.
bcp
## Probability X1 id
## 25 1 0.176899 25
strucchange
When looking at changes in the mean
##
## OLS-based CUSUM test
##
## data: ocus_mod
## S0 = 3.3164, p-value = 5.593e-10
##
## Optimal 2-segment partition:
##
## Call:
## breakpoints.formula(formula = z ~ 1, data = df)
##
## Breakpoints at observation number:
## 25
##
## Corresponding to breakdates:
## 0.5
##
## Optimal (m+1)-segment partition:
##
## Call:
## breakpoints.formula(formula = z ~ 1, data = df)
##
## Breakpoints at observation number:
##
## m = 1 25
## m = 2 25 38
## m = 3 14 25 38
## m = 4 7 14 25 38
## m = 5 7 14 25 36 43
## m = 6 7 14 21 28 36 43
##
## Corresponding to breakdates:
##
## m = 1 0.5
## m = 2 0.5 0.76
## m = 3 0.28 0.5 0.76
## m = 4 0.14 0.28 0.5 0.76
## m = 5 0.14 0.28 0.5 0.72 0.86
## m = 6 0.14 0.28 0.42 0.56 0.72 0.86
##
## Fit:
##
## m 0 1 2 3 4 5 6
## RSS 329.32 33.64 32.36 31.73 31.73 32.11 65.84
## BIC 243.97 137.72 143.62 150.46 158.27 166.70 210.42
To get the optimal number numerically, here is a solution:
bpts_sum <- summary(bpts)
opt_brks <- opt_bpts(bpts_sum$RSS["BIC",])
opt_brks
## [1] 1
All indicate 1 breakpoint in the middle:
## [1] 25
segmented
##
## ***Regression Model with Segmented Relationship(s)***
##
## Call:
## segmented.lm(obj = lin_mod, seg.Z = ~x, psi = 20)
##
## Estimated Break-Point(s):
## Est. St.Err
## 13.282 5.023
##
## Meaningful coefficients of the linear terms:
## Estimate Std. Error t value Pr(>|t|)
## (Intercept) 0.103317 0.813919 0.127 0.900
## x 0.002849 0.102544 0.028 0.978
## U1.x 0.175041 0.104733 1.671 NA
##
## Residual standard error: 1.383 on 46 degrees of freedom
## Multiple R-Squared: 0.7327, Adjusted R-squared: 0.7152
##
## Convergence attained in 14 iterations with relative change -0.002120593
## $x
## Est. St.Err. t value CI(95%).l CI(95%).u
## slope1 0.0028487 0.102540 0.02778 -0.20356 0.20926
## slope2 0.1778900 0.021301 8.35130 0.13501 0.22077
tree
3 changes in mean
set.seed(2)
# Normal distributed data with 3 change in mean (at x = 25-11, 25-26, 45-46)
df <- data.frame(
x = 1:50,
z=c(rnorm(10, 1, sd = 0.5), rnorm(15, 0, sd = 0.5),
rnorm(20, 2, sd = 0.5), rnorm(5, 0.5 , sd = 0.5))
)
plot(df$x, df$z, type = 'l', xlab = '', ylab = '')
lines(x = 1:10, y = rep(1,10), col = 'red', lwd = 3)
lines(x = 11:25, y = rep(0,15), col = 'red', lwd = 3)
lines(x = 26:45, y = rep(2,20), col = 'red', lwd = 3)
lines(x = 46:50, y = rep(0.5,5), col = 'red', lwd = 3)
changepoint
Testing for 1 changepoint
## Created Using changepoint version 2.2.2
## Changepoint type : Change in mean
## Method of analysis : AMOC
## Test Statistic : Normal
## Type of penalty : MBIC with value, 11.73607
## Minimum Segment Length : 1
## Maximum no. of cpts : 1
## Changepoint Locations :
Testing for several using PELT method and AIC penalty:
## Class 'cpt' : Changepoint Object
## ~~ : S4 class containing 12 slots with names
## cpttype date version data.set method test.stat pen.type pen.value minseglen cpts ncpts.max param.est
##
## Created on : Mon Apr 23 00:37:43 2018
##
## summary(.) :
## ----------
## Created Using changepoint version 2.2.2
## Changepoint type : Change in mean
## Method of analysis : PELT
## Test Statistic : Normal
## Type of penalty : AIC with value, 4
## Minimum Segment Length : 1
## Maximum no. of cpts : Inf
## Changepoint Locations : 10 26 46
Testing for several using PELT method and CROP type:
## [1] "Maximum number of runs of algorithm = 9"
## [1] "Completed runs = 2"
## [1] "Completed runs = 3"
## [1] "Completed runs = 5"
## [1] "Completed runs = 8"
## Created Using changepoint version 2.2.2
## Changepoint type : Change in mean
## Method of analysis : PELT
## Test Statistic : Normal
## Type of penalty : CROPS with value, 1 25
## Minimum Segment Length : 1
## Maximum no. of cpts : Inf
## Changepoint Locations :
## Number of segmentations recorded: 7 with between 0 and 7 changepoints.
## Penalty value ranges from: 1 to 14.06746
In the following order strong changepoints detected:
cpts_ord(cpts.full(cpt2))
## [1] 26 46 10 15 16 33 43
3 Changepoints detected
bcp
## Probability X1 id
## 26 0.868 0.6111902 26
strucchange
When looking at changes in the mean
##
## OLS-based CUSUM test
##
## data: ocus_mod
## S0 = 2.0704, p-value = 0.0003783
##
## Optimal 4-segment partition:
##
## Call:
## breakpoints.formula(formula = z ~ 1, data = df)
##
## Breakpoints at observation number:
## 10 26 34
##
## Corresponding to breakdates:
## 0.2 0.52 0.68
##
## Optimal (m+1)-segment partition:
##
## Call:
## breakpoints.formula(formula = z ~ 1, data = df)
##
## Breakpoints at observation number:
##
## m = 1 26
## m = 2 10 26
## m = 3 10 26 34
## m = 4 10 26 33 41
## m = 5 10 18 26 33 41
## m = 6 8 15 22 29 36 43
##
## Corresponding to breakdates:
##
## m = 1 0.52
## m = 2 0.2 0.52
## m = 3 0.2 0.52 0.68
## m = 4 0.2 0.52 0.66 0.82
## m = 5 0.2 0.36 0.52 0.66 0.82
## m = 6 0.16 0.3 0.44 0.58 0.72 0.86
##
## Fit:
##
## m 0 1 2 3 4 5 6
## RSS 40.14 26.07 21.49 18.01 17.08 16.30 22.59
## BIC 138.73 124.98 123.16 122.13 127.31 132.79 156.93
breakpoint anaylsis suggest 3 breakpoints, Fstats only 1 (in the middle) and the efp() function 2 (1 middle and 1 at end). BIC indicates also rather 3 breakpoints.
Get the optimal number numerically:
bpts_sum <- summary(bpts)
opt_brks <- opt_bpts(bpts_sum$RSS["BIC",])
opt_brks
## [1] 3
## [1] 10 26 34
segmented
##
## ***Regression Model with Segmented Relationship(s)***
##
## Call:
## segmented.lm(obj = lin_mod, seg.Z = ~x, psi = 20)
##
## Estimated Break-Point(s):
## Est. St.Err
## 44.990 1.304
##
## Meaningful coefficients of the linear terms:
## Estimate Std. Error t value Pr(>|t|)
## (Intercept) 0.334255 0.237984 1.405 0.16688
## x 0.034959 0.009211 3.795 0.00043 ***
## U1.x -0.468688 0.185701 -2.524 NA
## ---
## Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
##
## Residual standard error: 0.7759 on 46 degrees of freedom
## Multiple R-Squared: 0.3101, Adjusted R-squared: 0.2651
##
## Convergence attained in 2 iterations with relative change 0
## $x
## Est. St.Err. t value CI(95%).l CI(95%).u
## slope1 0.034959 0.0092113 3.7953 0.016418 0.053501
## slope2 -0.433730 0.1854700 -2.3385 -0.807060 -0.060393
tree
1 break in relationship
set.seed(3)
z <- numeric(20)
## Create first segment
z[1:10] <- 20:11 + rnorm(10, 0, 1.5)
## Create second segment
z[11:20] <- seq(11, 15, len=10) + rnorm(10, 0, 1.5)
df <- data.frame(x = 1:20, z = z)
plot(df$x, df$z, type='l',xlab='',ylab='')
lines(x = 1:10,y = 20:11, lwd = 3, col = 'red')
lines(x = 11:20, y = seq(11, 15, len=10), lwd = 3, col = 'red')
changepoint
Testing for 1 changepoint in mean
## Created Using changepoint version 2.2.2
## Changepoint type : Change in mean
## Method of analysis : AMOC
## Test Statistic : Normal
## Type of penalty : MBIC with value, 8.987197
## Minimum Segment Length : 1
## Maximum no. of cpts : 1
## Changepoint Locations : 6
Testing for several using PELT method and AIC penalty:
## Class 'cpt' : Changepoint Object
## ~~ : S4 class containing 12 slots with names
## cpttype date version data.set method test.stat pen.type pen.value minseglen cpts ncpts.max param.est
##
## Created on : Mon Apr 23 00:37:43 2018
##
## summary(.) :
## ----------
## Created Using changepoint version 2.2.2
## Changepoint type : Change in mean
## Method of analysis : PELT
## Test Statistic : Normal
## Type of penalty : AIC with value, 4
## Minimum Segment Length : 1
## Maximum no. of cpts : Inf
## Changepoint Locations : 3 8 13 18
Testing for several using PELT method and CROPS penalty:
## [1] "Maximum number of runs of algorithm = 8"
## [1] "Completed runs = 2"
## [1] "Completed runs = 3"
## [1] "Completed runs = 5"
## [1] "Completed runs = 6"
## [1] "Completed runs = 7"
## Created Using changepoint version 2.2.2
## Changepoint type : Change in mean
## Method of analysis : PELT
## Test Statistic : Normal
## Type of penalty : CROPS with value, 1 25
## Minimum Segment Length : 1
## Maximum no. of cpts : Inf
## Changepoint Locations :
## Number of segmentations recorded: 6 with between 1 and 7 changepoints.
## Penalty value ranges from: 1 to 24.57129
In the following order strong changepoints detected:
cpts_ord(cpts.full(cpt2))[1:3]
## [1] 6 8 18
3 strong changepoints detected.
bcp
## Probability X1 id
## 8 0.746 14.36749 8
strucchange
##
## OLS-based CUSUM test
##
## data: ocus_mod
## S0 = 0.78922, p-value = 0.5618
##
## Optimal 2-segment partition:
##
## Call:
## breakpoints.formula(formula = z ~ x, data = df)
##
## Breakpoints at observation number:
## 10
##
## Corresponding to breakdates:
## 0.5
##
## Optimal (m+1)-segment partition:
##
## Call:
## breakpoints.formula(formula = z ~ x, data = df)
##
## Breakpoints at observation number:
##
## m = 1 10
## m = 2 8 12
## m = 3 8 13 16
## m = 4 3 8 13 16
## m = 5 3 8 11 14 17
##
## Corresponding to breakdates:
##
## m = 1 0.5
## m = 2 0.4 0.6
## m = 3 0.4 0.65 0.8
## m = 4 0.15 0.4 0.65 0.8
## m = 5 0.15 0.4 0.55 0.7 0.85
##
## Fit:
##
## m 0 1 2 3 4 5
## RSS 110.17 19.51 16.97 13.91 11.11 10.24
## BIC 99.87 74.23 80.43 85.44 89.93 97.29
Get the optimal number numerically:
bpts_sum <- summary(bpts)
opt_brks <- opt_bpts(bpts_sum$RSS["BIC",])
opt_brks
## [1] 1
All indicate 1 breakpoint rather at the end:
## [1] 10
segmented
##
## ***Regression Model with Segmented Relationship(s)***
##
## Call:
## segmented.lm(obj = lin_mod, seg.Z = ~x, psi = 10)
##
## Estimated Break-Point(s):
## Est. St.Err
## 11.648 0.672
##
## Meaningful coefficients of the linear terms:
## Estimate Std. Error t value Pr(>|t|)
## (Intercept) 20.0262 0.7280 27.510 6.69e-15 ***
## x -0.8547 0.1073 -7.963 5.88e-07 ***
## U1.x 1.5052 0.1807 8.331 NA
## ---
## Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
##
## Residual standard error: 1.126 on 16 degrees of freedom
## Multiple R-Squared: 0.8609, Adjusted R-squared: 0.8348
##
## Convergence attained in 3 iterations with relative change 1.752145e-16
## $x
## Est. St.Err. t value CI(95%).l CI(95%).u
## slope1 -0.85473 0.10733 -7.9635 -1.08230 -0.62720
## slope2 0.65043 0.14533 4.4756 0.34235 0.95851
tree
Cubic decay function
set.seed(4)
x <- 1:50
z_nonoise <- (10000 + 0.05*x + 0.2*x^2 - 0.2*x^3)
z <- z_nonoise + rnorm(50,1000,500)
df <- data.frame(x = x, z = z)
plot(df$x, df$z, type = 'l', xlab = '', ylab = '')
changepoint
Testing for 1 changepoint in mean
## Created Using changepoint version 2.2.2
## Changepoint type : Change in mean
## Method of analysis : AMOC
## Test Statistic : Normal
## Type of penalty : MBIC with value, 11.73607
## Minimum Segment Length : 1
## Maximum no. of cpts : 1
## Changepoint Locations : 35
Testing for several using PELT method and AIC penalty:
## Class 'cpt' : Changepoint Object
## ~~ : S4 class containing 12 slots with names
## cpttype date version data.set method test.stat pen.type pen.value minseglen cpts ncpts.max param.est
##
## Created on : Mon Apr 23 00:37:43 2018
##
## summary(.) :
## ----------
## Created Using changepoint version 2.2.2
## Changepoint type : Change in mean
## Method of analysis : PELT
## Test Statistic : Normal
## Type of penalty : AIC with value, 4
## Minimum Segment Length : 1
## Maximum no. of cpts : Inf
## Number of changepoints: 49
Testing for several using PELT method and CROPS penalty:
## [1] "Maximum number of runs of algorithm = 2"
## [1] "Completed runs = 2"
## Created Using changepoint version 2.2.2
## Changepoint type : Change in mean
## Method of analysis : PELT
## Test Statistic : Normal
## Type of penalty : CROPS with value, 1 25
## Minimum Segment Length : 1
## Maximum no. of cpts : Inf
## Changepoint Locations :
## Range of segmentations:
## [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10] [,11] [,12] [,13]
## [1,] 1 2 3 4 5 6 7 8 9 10 11 12 13
## [,14] [,15] [,16] [,17] [,18] [,19] [,20] [,21] [,22] [,23] [,24]
## [1,] 14 15 16 17 18 19 20 21 22 23 24
## [,25] [,26] [,27] [,28] [,29] [,30] [,31] [,32] [,33] [,34] [,35]
## [1,] 25 26 27 28 29 30 31 32 33 34 35
## [,36] [,37] [,38] [,39] [,40] [,41] [,42] [,43] [,44] [,45] [,46]
## [1,] 36 37 38 39 40 41 42 43 44 45 46
## [,47] [,48] [,49]
## [1,] 47 48 49
##
## For penalty values: 1
Nothing detected.
bcp
## Probability X1 id
## 32 0.784 5591.184 32
## 43 0.902 -3204.395 43
strucchange
##
## OLS-based CUSUM test
##
## data: ocus_mod
## S0 = 1.5437, p-value = 0.01703
##
## Optimal 4-segment partition:
##
## Call:
## breakpoints.formula(formula = z ~ x, data = df)
##
## Breakpoints at observation number:
## 8 26 41
##
## Corresponding to breakdates:
## 0.16 0.52 0.82
##
## Optimal (m+1)-segment partition:
##
## Call:
## breakpoints.formula(formula = z ~ x, data = df)
##
## Breakpoints at observation number:
##
## m = 1 29
## m = 2 24 40
## m = 3 8 26 41
## m = 4 8 22 29 43
## m = 5 8 22 29 36 43
## m = 6 8 15 22 29 36 43
##
## Corresponding to breakdates:
##
## m = 1 0.58
## m = 2 0.48 0.8
## m = 3 0.16 0.52 0.82
## m = 4 0.16 0.44 0.58 0.86
## m = 5 0.16 0.44 0.58 0.72 0.86
## m = 6 0.16 0.3 0.44 0.58 0.72 0.86
##
## Fit:
##
## m 0 1 2 3 4 5 6
## RSS 4.406e+08 3.234e+07 1.195e+07 8.726e+06 7.056e+06 6.846e+06 6.645e+06
## BIC 9.532e+02 8.344e+02 7.963e+02 7.923e+02 7.934e+02 8.037e+02 8.139e+02
Get the optimal number numerically:
bpts_sum <- summary(bpts)
opt_brks <- opt_bpts(bpts_sum$RSS["BIC",])
opt_brks
## [1] 3
All indicate 1 breakpoint rather at the end:
## [1] 8 26 41
segmented
##
## ***Regression Model with Segmented Relationship(s)***
##
## Call:
## segmented.lm(obj = lin_mod, seg.Z = ~x, psi = 10)
##
## Estimated Break-Point(s):
## Est. St.Err
## 29.676 0.580
##
## Meaningful coefficients of the linear terms:
## Estimate Std. Error t value Pr(>|t|)
## (Intercept) 12288.57 319.63 38.447 < 2e-16 ***
## x -153.56 18.61 -8.252 1.26e-10 ***
## U1.x -826.77 35.49 -23.298 NA
## ---
## Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
##
## Residual standard error: 838.5 on 46 degrees of freedom
## Multiple R-Squared: 0.988, Adjusted R-squared: 0.9872
##
## Convergence attained in 2 iterations with relative change 3.455907e-16
## $x
## Est. St.Err. t value CI(95%).l CI(95%).u
## slope1 -153.56 18.609 -8.2516 -191.02 -116.1
## slope2 -980.32 30.216 -32.4440 -1041.10 -919.5
tree
Highly non-linear (3 changes in regression)
set.seed(5)
x <- 1:50
z_nonoise <- c(0.1*x[1:10], 1.5-0.2*(x[11:25]-11),
-1.5 + 0.2*(x[26:45]-26), rep(1,5))
z <- z_nonoise + rnorm(50,0,0.2)
df <- data.frame(x = x, z = z)
plot(df$x, df$z, type = 'l', xlab = '', ylab = '')
lines(x = 1:10,y = 0.1*x[1:10], lwd = 3, col = 'red')
lines(x = 11:25, y = 1.5-0.2*(x[11:25]-11), lwd = 3, col = 'red')
lines(x = 26:45, y = -1.5 + 0.2*(x[26:45]-26), lwd = 3, col = 'red')
lines(x = 46:50, y = rep(1,5), lwd = 3, col = 'red')
changepoint
Testing for 1 changepoint in mean
## Created Using changepoint version 2.2.2
## Changepoint type : Change in mean
## Method of analysis : AMOC
## Test Statistic : Normal
## Type of penalty : MBIC with value, 11.73607
## Minimum Segment Length : 1
## Maximum no. of cpts : 1
## Changepoint Locations :
Nothing found with the AMOC method.
Testing for several using PELT method and AIC penalty:
## Class 'cpt' : Changepoint Object
## ~~ : S4 class containing 12 slots with names
## cpttype date version data.set method test.stat pen.type pen.value minseglen cpts ncpts.max param.est
##
## Created on : Mon Apr 23 00:37:43 2018
##
## summary(.) :
## ----------
## Created Using changepoint version 2.2.2
## Changepoint type : Change in mean
## Method of analysis : PELT
## Test Statistic : Normal
## Type of penalty : AIC with value, 4
## Minimum Segment Length : 1
## Maximum no. of cpts : Inf
## Changepoint Locations : 17 32
Testing for several using PELT method and CROPS penalty:
## [1] "Maximum number of runs of algorithm = 8"
## [1] "Completed runs = 2"
## [1] "Completed runs = 3"
## [1] "Completed runs = 5"
## [1] "Completed runs = 7"
## Created Using changepoint version 2.2.2
## Changepoint type : Change in mean
## Method of analysis : PELT
## Test Statistic : Normal
## Type of penalty : CROPS with value, 1 25
## Minimum Segment Length : 1
## Maximum no. of cpts : Inf
## Changepoint Locations :
## Number of segmentations recorded: 7 with between 0 and 6 changepoints.
## Penalty value ranges from: 1 to 14.97552
In the following order 2 strong changepoints detected:
cpts_ord(cpts.full(cpt2))[1:2]
## [1] 39 17
bcp
## Probability X1 id
## 39 0.718 0.6137687 39
## 45 0.942 2.0753858 45
strucchange
##
## OLS-based CUSUM test
##
## data: ocus_mod
## S0 = 1.3915, p-value = 0.04161
##
## Optimal 4-segment partition:
##
## Call:
## breakpoints.formula(formula = z ~ x, data = df)
##
## Breakpoints at observation number:
## 10 26 43
##
## Corresponding to breakdates:
## 0.2 0.52 0.86
##
## Optimal (m+1)-segment partition:
##
## Call:
## breakpoints.formula(formula = z ~ x, data = df)
##
## Breakpoints at observation number:
##
## m = 1 31
## m = 2 23 43
## m = 3 10 26 43
## m = 4 10 25 36 43
## m = 5 10 18 25 36 43
## m = 6 7 14 22 29 36 43
##
## Corresponding to breakdates:
##
## m = 1 0.62
## m = 2 0.46 0.86
## m = 3 0.2 0.52 0.86
## m = 4 0.2 0.5 0.72 0.86
## m = 5 0.2 0.36 0.5 0.72 0.86
## m = 6 0.14 0.28 0.44 0.58 0.72 0.86
##
## Fit:
##
## m 0 1 2 3 4 5 6
## RSS 36.889 14.781 8.544 2.724 2.330 2.079 3.047
## BIC 138.424 104.434 88.760 43.337 47.264 53.304 84.158
The pattern is less clear but the BIC suggest clearly 3 changepoints.
Get the optimal number numerically:
bpts_sum <- summary(bpts)
opt_brks <- opt_bpts(bpts_sum$RSS["BIC",])
opt_brks
## [1] 3
The breakpoints are located at x =…
## [1] 10 26 43
segmented
##
## ***Regression Model with Segmented Relationship(s)***
##
## Call:
## segmented.lm(obj = lin_mod, seg.Z = ~x, psi = list(x = c(10,
## 20, 40)))
##
## Estimated Break-Point(s):
## Est. St.Err
## psi1.x 11.019 0.703
## psi2.x 25.998 0.526
## psi3.x 43.972 0.515
##
## Meaningful coefficients of the linear terms:
## Estimate Std. Error t value Pr(>|t|)
## (Intercept) -0.10879 0.16986 -0.640 0.525
## x 0.12495 0.02505 4.989 1.1e-05 ***
## U1.x -0.29823 0.03050 -9.777 NA
## U2.x 0.36098 0.02111 17.098 NA
## U3.x -0.43043 0.05106 -8.431 NA
## ---
## Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
##
## Residual standard error: 0.2627 on 42 degrees of freedom
## Multiple R-Squared: 0.9266, Adjusted R-squared: 0.9144
##
## Convergence attained in 21 iterations with relative change -0.00365248
## $x
## Est. St.Err. t value CI(95%).l CI(95%).u
## slope1 0.12495 0.025045 4.9890 0.074406 0.17549
## slope2 -0.17328 0.017415 -9.9501 -0.208430 -0.13814
## slope3 0.18769 0.011934 15.7280 0.163610 0.21178
## slope4 -0.24274 0.049641 -4.8899 -0.342920 -0.14256
tree
Conclusion
Changes in mean:
All methods detected the true changepoints in the data EXCEPT for the segmented
package!
changepoint
:- disadvantage here is that one needs to specify a priori if 1 or multiple changes and
- there are many parameters to set (in my examples, however, resulted in same changepoints)
- when penalty = “CROPS”, one needs to visually inspect the optimal number of changepoints
bcp
:- easy to use, not much to specify
- no specification of changepoints to set a priori
strucchange
:- can cope with many model types, also for changes in means by specifying y ~ 1
- provides confidence intervals of changepoints
- several test statistics for checking for structural changes:
sctest()
,Fstats()
,breakpoints()
,plot(breakpoints())
- disav.: need to inspect visually number of optimal changepoints (with broken stick plot of BIC)
- disav.: sum of the output is tuned to ts object, needs some recoding to adjust to ordinary dataframe
segmented
: useless for changes in mean!tree
:- disadv.: gets sometimes more breakpoints –> how to choose the optimal one?
- adv.: interpolates changepoints –> identifies also continuous changepoints, which is maybe more suitable for continuous pressure variables
Changes in functional curves of relatioships between Y and X:
All methods that identify changes in mean are not suitable for this type of question. Only strucchange
and segmented
gave reasonable results. I would favour strucchange
over the other because
strucchange
:- provides several test statistics
- no a priori specification of changepoints, but: one needs to visuall inspect the BIC broken stick plot for optimal number of changepoints
- provides confidence intervals around the location of the changepoints!
- allows different type of model structures (but that also requires the correct specification –> I checked; only the plot of the epf function and the sctest will differ; Fstats and breakpoint analysis remains the same)
segmented
:- disadv.: requires starting values for the changepoints, hence, one needs to fix the number of changepoints a priori
- adv.: provides also confidence intervals around the location of the changepoints!
- very siple model structure only allowed
Cobb, G. W. (1978). The problem of the Nile: conditional solution to a change-point problem. Biometrika 65, 243–51. doi: 10.2307/2335202.↩


Hi I'm Leanne!
I'm currently an undergraduate student studying Interactive Digital Media at Drexel University.
New Yorker, Disney lover, bunny admirer.
Roam around and see what you like!
Hi I'm Leanne!
I'm currently an undergraduate student studying Interactive Digital Media at Drexel University.
New Yorker, Disney lover, bunny admirer.
Roam around and see what you like!


Gaia is a collection of web apps for B2G OS.
Working Web Apps
None yet.
Currently Disabled Apps
Calendar
Camera
Clock
Dialer
Contacts
Cost Control
Email
FM Radio
Gallery
Music
SMS
Video


Add Body
Mass:
kg
Velocity:
{
,
}
m/s
Position:
{
,
}
m
Render
Time interval (s):
Duration (s):
Gravitational constant (N m^2 / k^2)
Number of Frames


Is it me you're looking for?
'cause I wonder where you are
And I wonder what you do
Are you somewhere feeling lonely?
Or is someone loving you?
Tell me how to win your heart
For I haven't got a clue
But let me start by saying I love you


All right! You’re on Lara’s waitlist.
Hi [User Name],
Thank you for joining the Lara new cities waitlist!
We see that your city isn't included in the recent beta launch for new cities, but don't worry, the Lara team is still working on bringing Lara to more cities based on users’ interests.
We will send you an update once Lara is ready for your city.
Stay awesome!
The RoadPreppers Team


@jjmerelo
, github.com/JJ
=begin pod :kind("Type") :subkind("class") :category("exception")
=TITLE class Failure
=SUBTITLE Delayed exception
class Failure is Nil { }
A C<Failure> is a I<soft> or I<unthrown> L<Exception|/type/Exception>,
usually generated by calling C<&fail>. It acts as a wrapper around an
L<Exception|/type/Exception> object.
=for comment
A lot of more stuff here
=end pod
Documentable
#| Everything documented inherits from this class
class Documentable {
has Str $.name;
has $.pod is required("Needs an actual document");
has Kind $.kind is required("Is essential metadata");
has @.subkinds = [];
has @.categories = [];
Pod::To::Cached
my $registry = Documentable::Registry.new(
:$topdir,
:dirs( $doc-dirs ),
:$typegraph-file
:verbose($v)
);
$registry.compose;
if ( $!use-cache ) {
$!pod-cache = init-cache( $!topdir, $!verbose);
say "Updating cache";
$!pod-cache.update-cache;
}
my %pod-to-render = Documentable::DocPage::Secondary.new.render($!registry, $name, $kind);
my Str $html = $!wrapper.render( %pod-to-render,
$kind.Str,
);
return %(
document => $html,
url => %pod-to-render
)
rsync -avu -e .
docs.raku.org@xxx.atikon.io:/var/www/docs.raku.org/
use LWP::Simple;
my $release = @*ARGS[0] // "2019.03";
my $document = LWP::Simple.get("https://raw.githubusercontent.com/rakudo/rakudo/master/docs/announce/$release.md");
my @parts = $document.split("\n +");
my $additions-removals = @parts[1,2,3].map: "\n# " ~ * ;
$additions-removals ~~ s:g/\s\s\s\+\s/* [ ] /;
$additions-removals ~~
s:g[ \[(<alnum>+)\] ] =
"-[$0](https://github.com/rakudo/rakudo/commit/$0)";
print $additions-removals;
Blame
helps with context# https://github.com/rakudo/rakudo/issues/2568
{
is-deeply 3 ~ ( 5 | "18" ), any("35","318"),
"does a junction survive ~ Junction";
is-deeply ( 5 | "18" ) ~ 3, any("53","183"),
"does a junction survive Junction ~";
is-deeply ( 5 | "18" ) ~ ( 3 | 6), any("53","56","183",186),
"does a junction survive Junction ~ Junction";
}
my &fail-routine = &fail;
unless &fail-routine.is-implementation-detail {
say "&fail is not an implementation detail, can expect backward compatibility";
}
sub PRIVATE-CALCULATION is implementation-detail {
#`(Not safe to rely on this)
}
if &PRIVATE-CALCULATION.is-implementation-detail {
say "You better not to rely on &PRIVATE-CALCULATION unless you really know what you are doing";
}


--- layout: page title: About header-img: "img/about-bg.png" ---
Teacher , coach and support specialist looking for a change.


Reports classes with only
private
constructors that are not extended by any nested class. Such classes can not be extended and should be declared
final
.


public class AggregatedList<A,E,K>
Given an ObservableListclass AggregatedList
groups the elements by the key into a fresh
ObservableList
Changes done to elements of the input list are reflected in the observable list of the respective group, whereas additions/removals of elements in the underlying list are reflected in the exposed ObservableList by adding/deleting aggregations as expected.
The ordering of the exposed list is based on the hashCode of keys. The ordering of the groups themselves is based on the hashCode of elements.
Warning: If there are two elements E in the source list that have the same hashCode then it is not deterministic which one will be removed if one is removed from the source list!
Example: val statesGroupedByCurrency = AggregatedList(states, { state -> state.currency }) { currency, group -> object { val currency = currency val states = group } }
The above creates an observable list of (currency, statesOfCurrency) pairs.
Note that update events to the source list are discarded, assuming the key of elements does not change. TODO Should we handle this case? It requires additional bookkeeping of sourceIndex->(aggregationIndex, groupIndex)
class AggregatedList
| Constructor and Description |
|---|
AggregatedList(javafx.collections.ObservableList<? extends E> list,
kotlin.jvm.functions.Function1<? super E,? extends K> toKey,
kotlin.jvm.functions.Function2<? super K,? super javafx.collections.ObservableList<E>,? extends A> assemble)
Given an ObservableList
class AggregatedList groups the elements by the key into a fresh
ObservableList |
| Modifier and Type | Method and Description |
|---|---|
A |
get(int index) |
kotlin.jvm.functions.Function2<K,javafx.collections.ObservableList,A> |
getAssemble() |
int |
getSize() |
int |
getSourceIndex(int index)
We cannot implement this as aggregations are one to many
|
kotlin.jvm.functions.Function1<E,K> |
getToKey() |
java.lang.Object |
remove(int p) |
java.lang.Object |
removeAt(int p) |
int |
size() |
void |
sourceChanged(javafx.collections.ListChangeListener.Change<? extends E> c) |
public AggregatedList(javafx.collections.ObservableList<? extends E> list, kotlin.jvm.functions.Function1<? super E,? extends K> toKey, kotlin.jvm.functions.Function2<? super K,? super javafx.collections.ObservableList<E>,? extends A> assemble)
Given an ObservableListclass AggregatedList
groups the elements by the key into a fresh
ObservableList
Changes done to elements of the input list are reflected in the observable list of the respective group, whereas additions/removals of elements in the underlying list are reflected in the exposed ObservableList by adding/deleting aggregations as expected.
The ordering of the exposed list is based on the hashCode of keys. The ordering of the groups themselves is based on the hashCode of elements.
Warning: If there are two elements E in the source list that have the same hashCode then it is not deterministic which one will be removed if one is removed from the source list!
Example: val statesGroupedByCurrency = AggregatedList(states, { state -> state.currency }) { currency, group -> object { val currency = currency val states = group } }
The above creates an observable list of (currency, statesOfCurrency) pairs.
Note that update events to the source list are discarded, assuming the key of elements does not change. TODO Should we handle this case? It requires additional bookkeeping of sourceIndex->(aggregationIndex, groupIndex)
list
- The underlying list.toKey
- Function to extract the key from an element.assemble
- Function to assemble the aggregation into the exposed A.class AggregatedList
public A get(int index)
public int getSourceIndex(int index)
We cannot implement this as aggregations are one to many
public int getSize()
public int size()
public void sourceChanged(javafx.collections.ListChangeListener.Change<? extends E> c)
public kotlin.jvm.functions.Function1<E,K> getToKey()
public kotlin.jvm.functions.Function2<K,javafx.collections.ObservableList,A> getAssemble()
public java.lang.Object removeAt(int p)
public java.lang.Object remove(int p)


Create JUnit tests to test each method thoroughly.
Recall that
to call static methods of the ListItem class
from your JUnit test methods, you can specify the class name each time,
as in ListItem.evenElements(ls). Alternatively, you can save characters and just write evenElements(ls) if you import the static methods from the ListItem class by adding the line
import static lab8.ListItem.*;
near the top of your file, after the package declaration.
As you work through these exercises, be sure to use recursion or iteration as indicated. Where not indicated, you may choose either approach. Each method will take references to list items as parameters. Unless otherwise specified, you should handle the case of a null parameter value.
pairwiseSum
PARAMETERS: two ListItem references, ls1 an ls2 RETURN VALUE: a ListItem at the front of a new list containing the pairwise sum of the elements in ls1 and ls2 for example, given lists ( 3 2 6 ) and ( 1 4 2), the return value would be the list ( 4 6 8 )You may assume that the given lists are the same length.
smallElements
PARAMETERS: a ListItem reference, ls an integer n RETURN VALUE: a new list identical to the given list, except that it contains no occurrences of numbers greater than n. for example, given input list ( 3 2 6 3 4 ) and 3, the return value would be the list ( 3 2 3 )
scale
PARAMETERS: a ListItem reference, ls an integer n RETURN VALUE: none (void) the procedure mutates the list by multiplying each number in the list by the given number n. for example, given input lists ( 3 2 6 3 4) and the number 3, the modified list would be ( 9 6 18 9 12 ).
insertAfter
PARAMETERS: a ListItem reference, ls two integers i and j (not equal) RETURN VALUE: none (void) the procedure mutates the list by inserting the given number i after each occurrence of j. for example, given input lists ( 3 2 6 3 4) and the number 5 and 3, the modified list would be ( 3 5 2 6 3 5 4 ).Be sure to do this by creating new list items only for the inserted numbers. Modifying the
next
references in the existing
ListItem objects to insert the new items in the right places.
Don't create a whole new list structure.
When you done with this extension, you must be cleared by the TA to receive credit.
- Commit all your work to your repository
- Fill in the form below with the relevant information
- Have a TA check your work
- The TA should check your work and then fill in his or her name
- Click OK while the TA watches
- If you request propagation, it does not happen immediately, but should be posted in the next day or so
This demo box is for extension 9.1
In the ListItem class, write methods with the following specifications, and write thorough JUnit tests to check that they work correctly.
reverseRecurse
that takes no
parameters and returns a ListItem. The return value should be
a new list structure that contains the same numbers as this list, but
in the reverse order. (Hint: Use a helper procedure with an extra
parameter that accumulates the reversed list.)
reverseLoop
that takes no
parameters and returns a ListItem. The return value should be
a new list structure that contains the same numbers as this list, but
in the reverse order. (Hint: Create a loop variable that's a ListItem reference
to keep track of your current position in the list.)
When you done with this extension, you must be cleared by the TA to receive credit.
- Commit all your work to your repository
- Fill in the form below with the relevant information
- Have a TA check your work
- The TA should check your work and then fill in his or her name
- Click OK while the TA watches
- If you request propagation, it does not happen immediately, but should be posted in the next day or so
This demo box is for extension 9.2
Issues: More points, unit tests, better stepwise description
This extension requires a substative development effort. It is possible I would give more points for this extension than are advertised. If you are interested please contact the instructor.
More specifically, you construct a model for simulating the shape of a catenary: the shape of our beloved St. Louis Gateway Arch.
Long before our city began its expansion into the NFL, the pioneers of our country expanded to the West, crossing the Mississippi and braving the perils of midwestern life. As a monument to their efforts, the City of St. Louis erected Eero Saarinen's famous Arch in 1965. Its grace, beauty, and elegance have inspired poets, musicians, and artists of the past five decades.
It's time that CSE131 had its turn.
A catenary is the shape made when you suspend a string by holding its ends, and let gravity pull on the string. If you look at a telephone wire strung between two poles, the shape you see is a catenary, though not one that would necessarily garner artistic praise.
It turns out that our Arch is also a catenary, but situated upside down.
How are we to simulate an catenary acting on a string? If we look really closely at the string, we see that it is composed of a series of mass points, with each adjacent pair of masses connected by a spring.
With gravity turned off, the picture is as follows:
You can use any data type to represent the masses and/or springs. Wisely you must choose, young padawan, for this choice will affect how much work you will have to put in for the remainder of this extension.
It is preferred that you do not account for the momentum of the masses. In the real world, when the masses fall, if they are held together by springs, they would bounce up and down until eventually the springs turn the kinetic energy of the masses into heat through internal friction. In this code, even if you account for momentum AND friction, it is very hard to get the masses to settle. So instead, for every round() calculate where the mass should be based on the force of gravity and the springs, and move it there.
Extra fun: Modify your solution so that the Arch starts at the bottom of the screen, and falls up instead of down.
When you done with this extension, you must be cleared by the TA to receive credit.
- Commit all your work to your repository
- Fill in the form below with the relevant information
- Have a TA check your work
- The TA should check your work and then fill in his or her name
- Click OK while the TA watches
- If you request propagation, it does not happen immediately, but should be posted in the next day or so
This demo box is for extension 9.3
Issues: Add some actual experiments to be done here. Double check that biojava still works.
Researchers in genetics and biology frequently collect samples of DNA that they then wish to analyze for certain properties. Biologists use such results to investigate diseases and their treatments, evolution, and the nature of biological systems.In this extension you will use a package developed to assist in processing biological data. Some of the processing occurs on your computer (locally), while some processing occurs at the NCBI and other institutions.
Throughout this work, you may wish to consult the following resources:
Note that we are using BioJava release 3. Earlier releases are still available on the web, but they are incompatible with release 3 and they tend not to work with NCBI.
More will be added -- stay tuned
When you done with this extension, you must be cleared by the TA to receive credit.
- Commit all your work to your repository
- Fill in the form below with the relevant information
- Have a TA check your work
- The TA should check your work and then fill in his or her name
- Click OK while the TA watches
- If you request propagation, it does not happen immediately, but should be posted in the next day or so
This demo box is for extension 9.4
Issues: Video for this
Note: This extension is especially recommended for those students who wish to continue with computer science studies. Others are welcome to complete it as well.Update your svn repository as usual to get the trees package in your extensions folder.
Implementation notes:
compareTo
method of the
Comparable interface.
For String values,
this method uses lexicographic ordering (dictionary ordering);
the compareTo
method takes as its parameter another String,
and returns an integer whose value is:
==
operator to compare objects for
equality.
When ==
is used on objects, it evaluates to true if both
sides of the comparison refer to the same exact memory location (i.e.,
it's the exact same object). For example, even if two String objects
contain the same text, the ==
test for equality on the
two objects would return false
if they are not
the same object.
public class OrderedListMap<K extends Comparable<K>,V> implements Mapnear the top of the file. The phrase "implements Map" means that this class conforms to the Map interface. In other words, this class must define all of the methods contained in the Map interface, and the compiler will check that this is indeed the case.
Notice also that the key type K is any Comparable object.
This will allow you to call the compareTo
method on the keys.
The values associated with key can be objects of any type.
One of the representation invariants for your OrderedListMap implementation should be that the list is kept in alphabetically sorted order according to the domain element. Use the fact that the list is kept in sorted order in order to improve the efficiency of the methods.
You can write additional test cases, but when you are finished, the provided test case OrderedListMapTest should run correctly. Also, be sure to verify that your toString methods produce the correct output. Verify that your list is being kept in sorted order.
Your remove method will require deleting elements from the tree. The usual way to delete nodes from a binary search tree is somewhat complicated, as discussed in class. Therefore, we are leaving the proper implementation of delete as an optional extension for this lab. If you don't want to do that extension, then you can implement delete by adding a boolean instance variable called deleted to your tree nodes. If you delete an element from the tree, you can just set deleted to true. Then, when a search reaches that node for the get or contains method, you can act as if the element is not in the tree.
Implement the toString
method so that it returns
a readable representation of the tree.
Display the tree sideways, with the root of
the tree at the left edge of the page.
Your return String should have one node
per line, something like this:
(quack,4) (oink,5) (moo,7) (meow,2) () (bow wow,8) (baa,5)This is called an in-order traversal of the tree, since one subtree is traversed first, then the node itself, and then the other subtree. You can use the special character
'\n'
in a String to cause the terminal to advance
to a new line as it prints the string.
Hint:
The depth of the node in the tree determines how much to indent.
So, use a helper procedure with a String parameter
that keeps track of the leading spaces
for each line of output. Start it out with the value ""
and then concatenate a String of spaces to create
the indentation String parameter for the recursive calls on both subtrees.
If you want, you can use the special tab character '\t'
instead of multiple spaces.
When you done with this extension, you must be cleared by the TA to receive credit.
- Commit all your work to your repository
- Fill in the form below with the relevant information
- Have a TA check your work
- The TA should check your work and then fill in his or her name
- Click OK while the TA watches
- If you request propagation, it does not happen immediately, but should be posted in the next day or so
This demo box is for extension 9.5
Issues: Video for this
Implement deletion properly in your binary search tree. In particular, suppose you want to remove node x from the tree.
When you done with this extension, you must be cleared by the TA to receive credit.
- Commit all your work to your repository
- Fill in the form below with the relevant information
- Have a TA check your work
- The TA should check your work and then fill in his or her name
- Click OK while the TA watches
- If you request propagation, it does not happen immediately, but should be posted in the next day or so
This demo box is for extension 9.6


Menu item
Toggle CSS
My Comics JSON
Browser Save
Export
Series
Issue
All
searching...
View Stats
Series
3
Have
3
Issues
3
Duplicates
3
Tight Detail
Medium Detail
Comic Vine ID:
CV Link:
Have Color Key
Have None
Have 1
Have Many
+ Add Issue
issue
have
coverdate
title
paid
where
when
Comic Vine ID:
Have Color Key
Have None
Have 1
Have Many
+ Add Issue
-1
Series List
X
Search
+
Comic Vine - NAME - vol. 1 - 1981
Marvel - NAME - vol. 1 - 1981
Add Detail
:
:
:
:
:
:
:
Add Detail
:
:
:
:
:
:
:
Comic Vine - X-Men - vol. 1 - 1963
Comic Vine - Uncanny X-Men - vol. 1 - 1981
Comic Vine - Uncanny X-Men - vol. 1 - 1981
ways to add issue add range of numbers special-1 1 1-5 for TPB


Лист1
Case, Call, Expected result, Passed, Is autotests covered, Stage
Check token addresses for wallet without pubkey declaration, tokenaddress," result":" success", all addresses start from" R", Initialization
Check token addresses for a specific pubkey, tokenaddres...


Https
Time:
× Unfinished...
Get Response
Http2
Time:
× Unfinished...
Get Response
Options
Request Num:
Request Size (Mb):
Request Delay (ms):


this file is located at /www/index.html
Platform:
Version:
Device Name:
UUID:
X:
Y:
Z:
Watch Accelerometer
Get Location
Call 411
Send SMS
Custom Alert
Beep
Vibrate
Exit
Get Fourth Contact