The following was printed in the St. John's Express, St. John's, Newfoundland, Canada. All views are the authors, but copyright is held by Robinson-Blackmore, 1998.
Movie Review by Mikel J. Koven
I think that saying that The X-Files is one of this summer's most anticipated films is safe. For five years, "The X-Files" television show has developed a dedicated fan culture, whose rabid devotion to the series rivals that of "Star Trek" fans. The premise of both the movie and the television series is two FBI agents who investigate the paranormal; Fox Mulder (David Duchovny) is the avid believer whose quest to find the truth about extraterrestrial life borders on the paranoid, and Dana Scully (Gillian Anderson) is the scientific skeptic trying to find a rational explanation to Mulder's flights of fancy. Outlining the plot of The X-Files movie is virtually impossible, since to be general would result in confusion, yet to be specific would give too much away. Nevertheless, I will try. "The black ooze," and extraterrestrial, virus-like substance is threatening Earth. A "shadow government" is aware of this, but tries to cover-up the alien existence. Mulder and Scully know "the truth is out there," and so try to expose both the invasion and the cover-up. There are three central questions I have heard asked about this movie: 1. Will those who don't watch the series be able to understand the movie? Yes. Isolated as an individual text, The X-Files can stand alone. They have given enough background for anyone, familiar with the show or not, to understand the movie. Although some of the secondary characters' histories may confuse the uninitiated, those characters are not essential to the film. This is a major problem: they trot out token secondary characters from the series out for an appearance and then disappear just as quickly. Why bring Superintendent Skinner into the picture in the first place, and then have him sat silently on an FBI internal affairs committee? Why bring in "The Lone Gunmen," three computer geek conspiracy theorists, for an even briefer appearance? These characters are recurrent on the series, and their appearance in the film was met with whoops from the audience (suggesting their popularity among fans - actually most of the audience could pass for "the Lone Gunmen"). Still, then they vanish just as quickly. 2. The television show never gives us any answers. Will the movie actually explain some things? Yes.  We finally get some understanding of the motivations behind the "shadow government." There are even some subtle tie-ins with contemporary UFO-ology, including the "greys" and the Roswell Crash of 1947. 3. Is the movie any good? No. The X-Files is a dreadful movie and shows some fundamental problems with writer/creator Chris Carter's talents and the relationship between cinema and television. First off, the screenplay by series creator Chris Carter is sloppy and cliched. After approximately forty-five minutes (the length of a television episode minus the commercials), the pace drops to a snail's crawl. Not long after that point, when Carter attempts to answer some questions we have had about the series, we wish he had not. The explanations are so trite and ridiculous that one would have preferred it had Carter not explained quite so much. I am willing to suspend my disbelief a fair bit, but the absurdity Carter wants me to swallow was just too much. Breaking the suspension of disbelief destroys the movie - and listening to other fans leave the cinema, maybe the series too. The explanations are not only absurd, they are tired and unoriginal. The extraterrestrials breed and gestate like those from the Alien series, and their craft looks like a leftover set piece from Independence Day. Note that the Alien movies, ID4, and The X-Files are all from 20thCentury Fox - a studio that is beginning to cannibalize itself I think. The X-Files is noteworthy for being the only movie based on a television series to be produced while the series was still running. In comparing the movie and television series certain aspects of the respective media emerge. The avoidance of the series to answer the questions it raised annoyed and frustrated many people. However, I rather liked that about the series. Television allows you to impose as much, or as little, meaning on a show as you want. It is the proverbial "blank screen" which we project our minds on. Meaning on television is open and ambiguous; it is the nature of the medium. Cinema, on the other hand, is the opposite. It projects onto us the filmmakers mind. We can, in some films, fill the textual gaps ourselves, but that almost never happens in an American film. Meaning, in cinema, needs to be self-contained and determined. So, when The X-Files made that jump from small to big screen, Carter needed to take into consideration the differences in the medium as well. He did not. By making explicit, what the television show left implicit, Carter reveals the limits of his creativity and skill. When they say that "fans" make a TV show, it is not far from the truth. On television, fan culture must impose its meanings on the text because there is nothing there. How true that is when we see the "explicit" X-Files - there is nothing there.
Rating: * (out of four)
--------------C6203DBE2EE2D65EFCC41C3B
The following was printed in the St. John's Express, St. John's, Newfoundland, Canada.
All views are the authors, but copyright is held by Robinson-Blackmore, 1998.
Movie Review
by Mikel J. Koven
I think that saying that The X-Files is one of this summer's most
anticipated films is safe. For five years, "The X-Files" television
show has developed a dedicated fan culture, whose rabid devotion to the
series rivals that of "Star Trek" fans.
The premise of both the movie and the television series is two
FBI agents who investigate the paranormal; Fox Mulder (David Duchovny)
is the avid believer whose quest to find the truth about extraterrestrial
life borders on the paranoid, and Dana Scully (Gillian Anderson) is the
scientific skeptic trying to find a rational explanation to Mulder's flights
of fancy.
Outlining the plot of The X-Files movie is virtually impossible,
since to be general would result in confusion, yet to be specific would
give too much away. Nevertheless, I will try. "The black ooze,"
and extraterrestrial, virus-like substance is threatening Earth.
A "shadow government" is aware of this, but tries to cover-up the alien
existence. Mulder and Scully know "the truth is out there," and so
try to expose both the invasion and the cover-up.
There are three central questions I have heard asked about this
movie:
1. Will those who don't watch the series be able to understand
the movie? Yes. Isolated as an individual text, The X-Files
can stand alone. They have given enough background for anyone, familiar
with the show or not, to understand the movie. Although some of the
secondary characters' histories may confuse the uninitiated, those characters
are not essential to the film. This is a major problem: they trot
out token secondary characters from the series out for an appearance and
then disappear just as quickly.
Why bring Superintendent Skinner into the picture in the first
place, and then have him sat silently on an FBI internal affairs committee?
Why bring in "The Lone Gunmen," three computer geek conspiracy theorists,
for an even briefer appearance? These characters are recurrent on
the series, and their appearance in the film was met with whoops from the
audience (suggesting their popularity among fans - actually most of the
audience could pass for "the Lone Gunmen"). Still, then they vanish
just as quickly.
2. The television show never gives us any answers.
Will the movie actually explain some things? Yes.  We finally get some understanding of the motivations behind
the "shadow government." There are even some subtle tie-ins with
contemporary UFO-ology, including the "greys" and the Roswell Crash of
1947.
3. Is the movie any good? No. The X-Files is
a dreadful movie and shows some fundamental problems with writer/creator
Chris Carter's talents and the relationship between cinema and television.
First off, the screenplay by series creator Chris Carter is sloppy
and cliched. After approximately forty-five minutes (the length of
a television episode minus the commercials), the pace drops to a snail's
crawl. Not long after that point, when Carter attempts to answer
some questions we have had about the series, we wish he had not.
The explanations are so trite and ridiculous that one would have preferred
it had Carter not explained quite so much. I am willing to suspend
my disbelief a fair bit, but the absurdity Carter wants me to swallow was
just too much. Breaking the suspension of disbelief destroys the
movie - and listening to other fans leave the cinema, maybe the series
too.
The explanations are not only absurd, they are tired and unoriginal.
The extraterrestrials breed and gestate like those from the Alien series,
and their craft looks like a leftover set piece from Independence Day.
Note that the Alien movies, ID4, and The X-Files are all from 20thCentury
Fox - a studio that is beginning to cannibalize itself I think.
The X-Files is noteworthy for being the only movie based on a
television series to be produced while the series was still running.
In comparing the movie and television series certain aspects of the respective
media emerge.
The avoidance of the series to answer the questions it raised
annoyed and frustrated many people. However, I rather liked that
about the series. Television allows you to impose as much, or as
little, meaning on a show as you want. It is the proverbial "blank
screen" which we project our minds on. Meaning on television is open
and ambiguous; it is the nature of the medium.
Cinema, on the other hand, is the opposite. It projects
onto us the filmmakers mind. We can, in some films, fill the textual
gaps ourselves, but that almost never happens in an American film.
Meaning, in cinema, needs to be self-contained and determined.
So, when The X-Files made that jump from small to big screen,
Carter needed to take into consideration the differences in the medium
as well. He did not. By making explicit, what the television
show left implicit, Carter reveals the limits of his creativity and skill.
When they say that "fans" make a TV show, it is not far from
the truth. On television, fan culture must impose its meanings on
the text because there is nothing there. How true that is when we
see the "explicit" X-Files - there is nothing there.
Rating: * (out of four)
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Our custom developed solutions have demonstrated higher value, lower cost of ownership and consistent performance in the last 7 years. Not to mention, we have managed to maintain 100% client retention rate for our custom developed applications.
Start-ups, ISVs, Enterprises alike have leveraged our custom software application development services to build reliable, scalable and low cost solutions based on their unique process or design requirements. We owe our success to various flexible engagement models, together with expertise in technology components, open source softwares, software tools and multi-platform environments.
Custom Software Development Services Include:
HUHY Technologies offers half and full-day hands-on workshops for technology enthusiast who want to explore JAVA, Python, PHP, Big Data, Android, Oracle, MySQL, Unix and related Technologies. We create a welcoming environment for those who are hesitant around technology and we emphasize skills that can be put into practice right away. At HUHY, we have a good time with productive workshops.
We strive to be inclusive and accessible. We keep our prices as low as we can and that means we get a great balance of attendees. Trainings are held during the day, evenings, and weekends so that people can attend during the comfortable hours. We rely heavily on the digital skills. Our most successful marketing comes through e-mail newsletters and social media and we have strong word-of-mouth marketing for our sessions.
We're also proud to say that repeat attendance is high -- we often find that someone will take one session at HUHY, and then want to take more, and bring their friends and colleagues.
Key element to HUHY's step to success is our commitment to responding to our attendee's needs. We ask for feedback after every workshop, and we make deliberate changes to our curriculum based on those responses. We also take suggestions for workshops topics so we stay relevant to the needs of the changing digital landscape. If there's enough interest in a topic, we find a great instructor and add it to our roster.
The other key element to our success lies in providing a great experience for our attendees. We really try to make our attendees feel comfortable and welcome. We find that when people are in a relaxed and fun environment, it becomes easier for them to understand new concepts. Then when we see someone really 'get it' for the first time, that's when we know we've hit the mark. We like to say that HUHY Technologies is for anyone curious to learn more about technology.


{{userEmail}}
{{userNumber}}
{{userCity}}, {{userCountry}}
{{order.ORDER_ID}}
DELIVERD
{{order.ORDER_STATUS}}
{{order.HAWKER_STATUS}}{{order.ORDER_STATUS}}
Ticket #FOOD94285: My Order was failed but ammount has been dedicted from my account.
Ticket #FOOD94287: My Order was failed but ammount has been dedicted from my account.
Ticket #FOOD94295: My Order was failed but ammount has been dedicted from my account.


| bit64-package {bit64} | R Documentation |
Package 'bit64' provides fast serializable S3 atomic 64bit (signed) integers
that can be used in vectors, matrices, arrays and data.frames. Methods are
available for coercion from and to logicals, integers, doubles, characters
and factors as well as many elementwise and summary functions.
Version 0.8
With 'integer64' vectors you can store very large integers at the expense
of 64 bits, which is by factor 7 better than 'int64' from package 'int64'.
Due to the smaller memory footprint, the atomic vector architecture and
using only S3 instead of S4 classes, most operations are one to three orders
of magnitude faster: Example speedups are 4x for serialization, 250x for
adding, 900x for coercion and 2000x for object creation. Also 'integer64'
avoids an ongoing (potentially infinite) penalty for garbage collection
observed during existence of 'int64' objects (see code in example section).
Version 0.9
Package 'bit64' - which extends R with fast 64-bit integers - now has fast
(single-threaded) implementations the most important univariate algorithmic
operations (those based on hashing and sorting). We now have methods for
'match', '
'quantile', 'median' and 'summary'. Regarding data management we also have
novel generics 'unipos' (positions of the unique values), 'tiepos' (
positions of ties), 'keypos' (positions of foreign keys in a sorted
dimension table) and derived methods 'as.factor' and 'as.ordered'. This 64-
bit functionality is implemented carefully to be not slower than the
respective 32-bit operations in Base R and also to avoid outlying waiting
times observed with 'order', 'rank' and 'table' (speedup factors 20/16/200
respective). This increases the dataset size with wich we can work truly
interactive. The speed is achieved by simple heuristic optimizers in high-
level functions choosing the best from multiple low-level algorithms and
further taking advantage of a novel caching if activated. In an example R
session using a couple of these operations the 64-bit integers performed 22x
faster than base 32-bit integers, hash-caching improved this to 24x,
sortorder-caching was most efficient with 38x (caching hashing and sorting
is not worth it with 32x at duplicated RAM consumption).
integer64(length) ## S3 method for class 'integer64' is(x) ## S3 replacement method for class 'integer64' length(x) <- value ## S3 method for class 'integer64' print(x, quote=FALSE, ...) ## S3 method for class 'integer64' str(object, vec.len = strO$vec.len, give.head = TRUE, give.length = give.head, ...)
length |
length of vector using |
x |
an integer64 vector |
object |
an integer64 vector |
value |
an integer64 vector of values to be assigned |
quote |
logical, indicating whether or not strings should be printed with surrounding quotes. |
vec.len |
see |
give.head |
see |
give.length |
see |
... |
further arguments to the |
| Package: | bit64 |
| Type: | Package |
| Version: | 0.5.0 |
| Date: | 2011-12-12 |
| License: | GPL-2 |
| LazyLoad: | yes |
| Encoding: | latin1 |
integer64
returns a vector of 'integer64',
i.e. a vector of double
decorated with class 'integer64'.
64 bit integers are related to big data: we need them to overcome address space limitations.
Therefore performance of the 64 bit integer type is critical.
In the S language – designed in 1975 – atomic objects were defined to be vectors for a couple of good reasons:
simplicity, option for implicit parallelization, good cache locality.
In recent years many analytical databases have learnt that lesson: column based data bases provide superior performance
for many applications, the result are products such as MonetDB, Sybase IQ, Vertica, Exasol, Ingres Vectorwise.
If we introduce 64 bit integers not natively in Base R but as an external package, we should at least strive to
make them as 'basic' as possible. Therefore the design choice of bit64 not only differs from int64
, it is obvious:
Like the other atomic types in Base R, we model data type 'integer64' as a contiguous atomic
vector in memory,
and we use the more basic S3
class system, not S4
. Like package int64
we want our 'integer64' to be serializeable
,
therefore we also use an existing data type as the basis. Again the choice is obvious: R has only one 64 bit data type: doubles.
By using doubles
, integer64
inherits
some functionality such as is.atomic
, length
,
length<-
, names
, names<-
, dim
, dim<-
, dimnames
, dimnames
.
Our R level functions strictly follow the functional programming paragdim:
no modification of arguments or other sideffects. Before version 0.93 we internally deviated from the strict paradigm
in order to boost performance. Our C functions do not create new return values,
instead we pass-in the memory to be returned as an argument. This gives us the freedom to apply the C-function
to new or old vectors, which helps to avoid unnecessary memory allocation, unnecessary copying and unnessary garbage collection.
Prior to 0.93 within our R functions we also deviated from conventional R programming by not using attr<-
and attributes<-
because they always did new memory allocation and copying in older R versions. If we wanted to set attributes of return values that we have freshly created,
we instead used functions setattr
and setattributes
from package bit
.
From version 0.93 setattr
is only used for manipulating cache
objects, in ramsort.integer64
and sort.integer64
and in as.data.frame.integer64
.
The fact that we introduce 64 bit long long integers – without introducing 128-bit long doubles – creates some subtle challenges:
Unlike 32 bit integers
, the integer64
are no longer a proper subset of double
.
If a binary arithmetic operation does involve a double
and a integer
, it is a no-brainer to return double
without loss of information. If an integer64
meets a double
, it is not trivial what type to return.
Switching to integer64
limits our ability to represent very large numbers, switching to double
limits our ability
to distinguish x
from x+1
. Since the latter is the purpose of introducing 64 bit integers, we usually return integer64
from functions involving integer64
, for example in c
, cbind
and rbind
.
Different from Base R, our operators +
,
-
, %/%
and %%
coerce their arguments to
integer64
and always return integer64
.
The multiplication operator *
coerces its first argument to integer64
but allows its second argument to be also double
: the second argument is internaly coerced to 'long double'
and the result of the multiplication is returned as integer64
.
The division /
and power ^
operators also coerce their first argument to integer64
and coerce internally their second argument to 'long double', they return as double
, like sqrt
,
log
, log2
and log10
do.
| argument1 | op | argument2 | -> | coerced1 | op | coerced2 | -> | result |
| integer64 | + | double | -> | integer64 | + | integer64 | -> | integer64 |
| double | + | integer64 | -> | integer64 | + | integer64 | -> | integer64 |
| integer64 | - | double | -> | integer64 | - | integer64 | -> | integer64 |
| double | - | integer64 | -> | integer64 | - | integer64 | -> | integer64 |
| integer64 | %/% | double | -> | integer64 | %/% | integer64 | -> | integer64 |
| double | %/% | integer64 | -> | integer64 | %/% | integer64 | -> | integer64 |
| integer64 | %% | double | -> | integer64 | %% | integer64 | -> | integer64 |
| double | %% | integer64 | -> | integer64 | %% | integer64 | -> | integer64 |
| integer64 | * | double | -> | integer64 | * | long double | -> | integer64 |
| double | * | integer64 | -> | integer64 | * | integer64 | -> | integer64 |
| integer64 | / | double | -> | integer64 | / | long double | -> | double |
| double | / | integer64 | -> | integer64 | / | long double | -> | double |
| integer64 | ^ | double | -> | integer64 | / | long double | -> | double |
| double | ^ | integer64 | -> | integer64 | / | long double | -> | double |
Our creator function integer64
takes an argument length
, creates an atomic double vector of this length,
attaches an S3 class attribute 'integer64' to it, and that's it. We simply rely on S3 method dispatch and interpret those
64bit elements as 'long long int'.
is.double
currently returns TRUE for integer64
and might return FALSE in a later release.
Consider is.double
to have undefined behaviour and do query is.integer64
before querying is.double
.
The methods is.integer64
and is.vector
both return TRUE
for integer64
.
Note that we did not patch storage.mode
and typeof
, which both continue returning 'double'
Like for 32 bit integer
, mode
returns 'numeric' and as.double
) tries coercing to double
).
It is possible that 'integer64' becomes a vmode
in package ff
.
Further methods for creating integer64
are range
which returns the range of the data type if calles without arguments,
rep
, seq
.
For all available methods on integer64
vectors see the index below and the examples.
| creating,testing,printing | see also | description |
NA_integer64_ | NA_integer_ | NA constant |
integer64 | integer | create zero atomic vector |
runif64 | runif | create random vector |
rep.integer64 | rep | |
seq.integer64 | seq | |
is.integer64 | is | |
is.integer | inherited from Base R | |
is.vector.integer64 | is.vector | |
identical.integer64 | identical | |
length<-.integer64 | length<- | |
length | inherited from Base R | |
names<- | inherited from Base R | |
names | inherited from Base R | |
dim<- | inherited from Base R | |
dim | inherited from Base R | |
dimnames<- | inherited from Base R | |
dimnames | inherited from Base R | |
str | inherited from Base R, does not print values correctly | |
print.integer64 | print | |
str.integer64 | str | |
| coercing to integer64 | see also | description |
as.integer64 | generic | |
as.integer64.bitstring | as.bitstring | |
as.integer64.character | character | |
as.integer64.double | double | |
as.integer64.integer | integer | |
as.integer64.integer64 | integer64 | |
as.integer64.logical | logical | |
as.integer64.NULL | NULL | |
| coercing from integer64 | see also | description |
as.bitstring | as.bitstring | generic |
as.bitstring.integer64 | ||
as.character.integer64 | as.character | |
as.double.integer64 | as.double | |
as.integer.integer64 | as.integer | |
as.logical.integer64 | as.logical | |
| data structures | see also | description |
c.integer64 | c | vector concatenate |
cbind.integer64 | cbind | column bind |
rbind.integer64 | rbind | row bind |
as.data.frame.integer64 | as.data.frame | coerce atomic object to data.frame |
data.frame | inherited from Base R since we have coercion | |
| subscripting | see also | description |
[.integer64 | [ | vector and array extract |
[<-.integer64 | [<- | vector and array assign |
[[.integer64 | [[ | scalar extract |
[[<-.integer64 | [[<- | scalar assign |
| binary operators | see also | description |
+.integer64 | + | returns integer64 |
-.integer64 | - | returns integer64 |
*.integer64 | * | returns integer64 |
^.integer64 | ^ | returns double |
/.integer64 | / | returns double |
%/%.integer64 | %/% | returns integer64 |
%%.integer64 | %% | returns integer64 |
| comparison operators | see also | description |
==.integer64 | == | |
!=.integer64 | != | |
<.integer64 | < | |
<=.integer64 | <= | |
>.integer64 | > | |
>=.integer64 | >= | |
| logical operators | see also | description |
!.integer64 | ! | |
&.integer64 | & | |
|.integer64 | | | |
xor.integer64 | xor | |
| math functions | see also | description |
is.na.integer64 | is.na | returns logical |
format.integer64 | format | returns character |
abs.integer64 | abs | returns integer64 |
sign.integer64 | sign | returns integer64 |
log.integer64 | log | returns double |
log10.integer64 | log10 | returns double |
log2.integer64 | log2 | returns double |
sqrt.integer64 | sqrt | returns double |
ceiling.integer64 | ceiling | dummy returning its argument |
floor.integer64 | floor | dummy returning its argument |
trunc.integer64 | trunc | dummy returning its argument |
round.integer64 | round | dummy returning its argument |
signif.integer64 | signif | dummy returning its argument |
| cumulative functions | see also | description |
cummin.integer64 | cummin | |
cummax.integer64 | cummax | |
cumsum.integer64 | cumsum | |
cumprod.integer64 | cumprod | |
diff.integer64 | diff | |
| summary functions | see also | description |
range.integer64 | range | |
min.integer64 | min | |
max.integer64 | max | |
sum.integer64 | sum | |
mean.integer64 | mean | |
prod.integer64 | prod | |
all.integer64 | all | |
any.integer64 | any | |
| algorithmically complex functions | see also | description (caching) |
match.integer64 | match | position of x in table (h//o/so) |
%in%.integer64 | %in% | is x in table? (h//o/so) |
duplicated.integer64 | duplicated | is current element duplicate of previous one? (h//o/so) |
unique.integer64 | unique | (shorter) vector of unique values only (h/s/o/so) |
unipos.integer64 | unipos | positions corresponding to unique values (h/s/o/so) |
tiepos.integer64 | tiepos | positions of values that are tied (//o/so) |
keypos.integer64 | keypos | position of current value in sorted list of unique values (//o/so) |
as.factor.integer64 | as.factor | convert to (unordered) factor with sorted levels of previous values (//o/so) |
as.ordered.integer64 | as.ordered | convert to ordered factor with sorted levels of previous values (//o/so) |
table.integer64 | table | unique values and their frequencies (h/s/o/so) |
sort.integer64 | sort | sorted vector (/s/o/so) |
order.integer64 | order | positions of elements that would create sorted vector (//o/so) |
rank.integer64 | rank | (average) ranks of non-NAs, NAs kept in place (/s/o/so) |
quantile.integer64 | quantile | (existing) values at specified percentiles (/s/o/so) |
median.integer64 | median | (existing) value at percentile 0.5 (/s/o/so) |
summary.integer64 | summary | (/s/o/so) |
all.equal.integer64 | all.equal | test if two objects are (nearly) equal (/s/o/so) |
| helper functions | see also | description |
minusclass | minusclass | removing class attritbute |
plusclass | plusclass | inserting class attribute |
binattr | binattr | define binary op behaviour |
| tested I/O functions | see also | description |
read.table | inherited from Base R | |
write.table | inherited from Base R | |
serialize | inherited from Base R | |
unserialize | inherited from Base R | |
save | inherited from Base R | |
load | inherited from Base R | |
dput | inherited from Base R | |
dget | inherited from Base R | |
vector size of atomic vectors is still limited to .Machine$integer.max
.
However, external memory extending packages such as ff
or bigmemory
can extend their address space now with integer64
. Having 64 bit integers also help
with those not so obvious address issues that arise once we exchange data with SQL databases
and datawarehouses, which use big integers as surrogate keys, e.g. on indexed primary key columns.
This puts R into a relatively strong position compared to certain commercial statistical
softwares, which sell database connectivity but neither have the range of 64 bit integers,
nor have integers at all, nor have a single numeric data type in their macro-glue-language.
literals such as 123LL
would require changes to Base R, up to then we need to write (and call)
as.integer64(123L)
or as.integer64(123)
or as.integer64('123')
.
Only the latter allows to specify numbers beyond Base R's numeric data types and therefore is the recommended
way to use – using only one way may facilitate migrating code to literals at a later stage.
identical
with default parameters does not distinguish all bit-patterns of doubles.
For testing purposes we provide a wrapper identical.integer64
that will distinguish all bit-patterns.
It would be desireable to have a single call of identical
handle both, double
and integer64
.
the colon operator :
officially does not dispatches S3 methods, however, we have made it generic
from <- lim.integer64()[1] to <- from+99 from:to
As a limitation remains: it will only dispatch at its first argument from
but not at its second to
.
is.double
does not dispatches S3 methods, However, we have made it generic
and it will return FALSE
on integer64
.
c
only dispatches c.integer64
if the first argument is integer64
and it does not recursively dispatch the proper method when called with argument recursive=TRUE
Therefore
c(list(integer64,integer64))
does not work and for now you can only call
c.integer64(list(x,x))
generic binary operators fail to dispatch *any* user-defined S3 method
if the two arguments have two different S3 classes. For example we have two classes
bit
and bitwhich
sparsely representing boolean vectors
and we have methods &.bit
and &.bitwhich
. For an expression
involving both as in bit & bitwhich
, none of the two methods is dispatched.
Instead a standard method is dispatched, which neither handles bit
nor bitwhich
. Although it lacks symmetry, the better choice would be to
dispatch simply the method of the class of the first argument in case of class conflict.
This choice would allow authors of extension packages providing coherent behaviour
at least within their contributed classes. But as long as none of the package authors
methods is dispatched, he cannot handle the conflicting classes at all.
unlist
is not generic and if it were, we would face similar problems as with c()
vector
with argument mode='integer64'
cannot work without adjustment of Base R
as.vector
with argument mode='integer64'
cannot work without adjustment of Base R
is.vector
does not dispatch its method is.vector.integer64
mode<-
drops the class 'integer64' which is returned from as.integer64
.
Also it does not remove an existing class 'integer64' when assigning mode 'integer'.
storage.mode<-
does not support external data types such as as.integer64
matrix
does drop the 'integer64' class attribute.
array
does drop the 'integer64' class attribute.
In current R versions (1.15.1) this can be circumvented by activating the function
as.vector.integer64
further down this file.
However, the CRAN maintainer has requested to remove as.vector.integer64
,
even at the price of breaking previously working functionality of the package.
str
does not print the values of integer64
correctly
subscripting non-existing elements and subscripting with NA
s is currently not supported.
Such subscripting currently returns<PHONE_NUMBER>227407266
instead of NA
(the NA
value of the underlying double code).
Following the full R behaviour here would either destroy performance or require extensive C-coding.
integer64
are useful for handling database keys and exact counting in +-2^63.
Do not use them as replacement for 32bit integers, integer64 are not
supported for subscripting by R-core and they have different semantics
when combined with double. Do understand that integer64
can only be
useful over double
if we do not coerce it to double
.
While
integer + double -> double + double -> double
or
1L + 0.5 -> 1.5
for additive operations we coerce to integer64
integer64 + double -> integer64 + integer64 -> integer64
hence
as.integer64(1) + 0.5 -> 1LL + 0LL -> 1LL
see section "Arithmetic precision and coercion" above
Jens Oehlschlägel<EMAIL_ADDRESS>Maintainer: Jens Oehlschlägel<EMAIL_ADDRESS>integer
in base R
message("Using integer64 in vector") x <- integer64(8) # create 64 bit vector x is.atomic(x) # TRUE is.integer64(x) # TRUE is.numeric(x) # TRUE is.integer(x) # FALSE - debatable is.double(x) # FALSE - might change x[] <- 1:2 # assigned value is recycled as usual x[1:6] # subscripting as usual length(x) <- 13 # changing length as usual x rep(x, 2) # replicate as usual seq(as.integer64(1), 10) # seq.integer64 is dispatched on first given argument seq(to=as.integer64(10), 1) # seq.integer64 is dispatched on first given argument seq.integer64(along.with=x) # or call seq.integer64 directly # c.integer64 is dispatched only if *first* argument is integer64 ... x <- c(x,runif(length(x), max=100)) # ... and coerces everything to integer64 - including double x names(x) <- letters # use names as usual x message("Using integer64 in array - note that 'matrix' currently does not work") message("as.vector.integer64 removed as requested by the CRAN maintainer") message("as consequence 'array' also does not work anymore") message("we still can create a matrix or array by assigning 'dim'") y <- rep(as.integer64(NA), 12) dim(y) <- c(3,4) dimnames(y) <- list(letters[1:3], LETTERS[1:4]) y["a",] <- 1:2 # assigning as usual y y[1:2,-4] # subscripting as usual # cbind.integer64 dispatched on any argument and coerces everything to integer64 cbind(E=1:3, F=runif(3, 0, 100), G=c("-1","0","1"), y) message("Using integer64 in data.frame") str(as.data.frame(x)) str(as.data.frame(y)) str(data.frame(y)) str(data.frame(I(y))) d <- data.frame(x=x, y=runif(length(x), 0, 100)) d d$x message("Using integer64 with csv files") fi64 <- tempfile() write.csv(d, file=fi64, row.names=FALSE) e <- read.csv(fi64, colClasses=c("integer64", NA)) unlink(fi64) str(e) identical.integer64(d$x,e$x) message("Serializing and unserializing integer64") dput(d, fi64) e <- dget(fi64) identical.integer64(d$x,e$x) e <- d[,] save(e, file=fi64) rm(e) load(file=fi64) identical.integer64(d,e) ### A couple of unit tests follow hidden in a dontshow{} directive ### ## Not run: message("== Differences between integer64 and int64 ==") require(bit64) require(int64) message("-- integer64 is atomic --") is.atomic(integer64()) #is.atomic(int64()) str(integer64(3)) #str(int64(3)) message("-- The following performance numbers are measured under RWin64 --") message("-- under RWin32 the advantage of integer64 over int64 is smaller --") message("-- integer64 needs 7x/5x less RAM than int64 under 64/32 bit OS (and twice the RAM of integer as it should be) --") #as.vector(object.size(int64(1e6))/object.size(integer64(1e6))) as.vector(object.size(integer64(1e6))/object.size(integer(1e6))) message("-- integer64 creates 2000x/1300x faster than int64 under 64/32 bit OS (and 3x the time of integer) --") t32 <- system.time(integer(1e8)) t64 <- system.time(integer64(1e8)) #T64 <- system.time(int64(1e7))*10 # using 1e8 as above stalls our R on an i7 8 GB RAM Thinkpad #T64/t64 t64/t32 i32 <- sample(1e6) d64 <- as.double(i32) message("-- the following timings are rather conservative since timings of integer64 include garbage collection -- due to looped calls") message("-- integer64 coerces 900x/100x faster than int64 under 64/32 bit OS (and 2x the time of coercing to integer) --") t32 <- system.time(for(i in 1:1000)as.integer(d64)) t64 <- system.time(for(i in 1:1000)as.integer64(d64)) #T64 <- system.time(as.int64(d64))*1000 #T64/t64 t64/t32 td64 <- system.time(for(i in 1:1000)as.double(i32)) t64 <- system.time(for(i in 1:1000)as.integer64(i32)) #T64 <- system.time(for(i in 1:10)as.int64(i32))*100 #T64/t64 t64/td64 message("-- integer64 serializes 4x/0.8x faster than int64 under 64/32 bit OS (and less than 2x/6x the time of integer or double) --") t32 <- system.time(for(i in 1:10)serialize(i32, NULL)) td64 <- system.time(for(i in 1:10)serialize(d64, NULL)) i64 <- as.integer64(i32); t64 <- system.time(for(i in 1:10)serialize(i64, NULL)) rm(i64); gc() #I64 <- as.int64(i32); #T64 <- system.time(for(i in 1:10)serialize(I64, NULL)) #rm(I64); gc() #T64/t64 t64/t32 t64/td64 message("-- integer64 adds 250x/60x faster than int64 under 64/32 bit OS (and less than 6x the time of integer or double) --") td64 <- system.time(for(i in 1:100)d64+d64) t32 <- system.time(for(i in 1:100)i32+i32) i64 <- as.integer64(i32); t64 <- system.time(for(i in 1:100)i64+i64) rm(i64); gc() #I64 <- as.int64(i32); #T64 <- system.time(for(i in 1:10)I64+I64)*10 #rm(I64); gc() #T64/t64 t64/t32 t64/td64 message("-- integer64 sums 3x/0.2x faster than int64 (and at about 5x/60X the time of integer and double) --") td64 <- system.time(for(i in 1:100)sum(d64)) t32 <- system.time(for(i in 1:100)sum(i32)) i64 <- as.integer64(i32); t64 <- system.time(for(i in 1:100)sum(i64)) rm(i64); gc() #I64 <- as.int64(i32); #T64 <- system.time(for(i in 1:100)sum(I64)) #rm(I64); gc() #T64/t64 t64/t32 t64/td64 message("-- integer64 diffs 5x/0.85x faster than integer and double (int64 version 1.0 does not support diff) --") td64 <- system.time(for(i in 1:10)diff(d64, lag=2L, differences=2L)) t32 <- system.time(for(i in 1:10)diff(i32, lag=2L, differences=2L)) i64 <- as.integer64(i32); t64 <- system.time(for(i in 1:10)diff(i64, lag=2L, differences=2L)) rm(i64); gc() t64/t32 t64/td64 message("-- integer64 subscripts 1000x/340x faster than int64 (and at the same speed / 10x slower as integer) --") ts32 <- system.time(for(i in 1:1000)sample(1e6, 1e3)) t32<- system.time(for(i in 1:1000)i32[sample(1e6, 1e3)]) i64 <- as.integer64(i32); t64 <- system.time(for(i in 1:1000)i64[sample(1e6, 1e3)]) rm(i64); gc() #I64 <- as.int64(i32); #T64 <- system.time(for(i in 1:100)I64[sample(1e6, 1e3)])*10 #rm(I64); gc() #(T64-ts32)/(t64-ts32) (t64-ts32)/(t32-ts32) message("-- integer64 assigns 200x/90x faster than int64 (and 50x/160x slower than integer) --") ts32 <- system.time(for(i in 1:100)sample(1e6, 1e3)) t32 <- system.time(for(i in 1:100)i32[sample(1e6, 1e3)] <- 1:1e3) i64 <- as.integer64(i32); i64 <- system.time(for(i in 1:100)i64[sample(1e6, 1e3)] <- 1:1e3) rm(i64); gc() #I64 <- as.int64(i32); #I64 <- system.time(for(i in 1:10)I64[sample(1e6, 1e3)] <- 1:1e3)*10 #rm(I64); gc() #(T64-ts32)/(t64-ts32) (t64-ts32)/(t32-ts32) tdfi32 <- system.time(dfi32 <- data.frame(a=i32, b=i32, c=i32)) tdfsi32 <- system.time(dfi32[1e6:1,]) fi32 <- tempfile() tdfwi32 <- system.time(write.csv(dfi32, file=fi32, row.names=FALSE)) tdfri32 <- system.time(read.csv(fi32, colClasses=rep("integer", 3))) unlink(fi32) rm(dfi32); gc() i64 <- as.integer64(i32); tdfi64 <- system.time(dfi64 <- data.frame(a=i64, b=i64, c=i64)) tdfsi64 <- system.time(dfi64[1e6:1,]) fi64 <- tempfile() tdfwi64 <- system.time(write.csv(dfi64, file=fi64, row.names=FALSE)) tdfri64 <- system.time(read.csv(fi64, colClasses=rep("integer64", 3))) unlink(fi64) rm(i64, dfi64); gc() #I64 <- as.int64(i32); #tdfI64 <- system.time(dfI64<-data.frame(a=I64, b=I64, c=I64)) #tdfsI64 <- system.time(dfI64[1e6:1,]) #fI64 <- tempfile() #tdfwI64 <- system.time(write.csv(dfI64, file=fI64, row.names=FALSE)) #tdfrI64 <- system.time(read.csv(fI64, colClasses=rep("int64", 3))) #unlink(fI64) #rm(I64, dfI64); gc() message("-- integer64 coerces 40x/6x faster to data.frame than int64 (and factor 1/9 slower than integer) --") #tdfI64/tdfi64 tdfi64/tdfi32 message("-- integer64 subscripts from data.frame 20x/2.5x faster than int64 (and 3x/13x slower than integer) --") #tdfsI64/tdfsi64 tdfsi64/tdfsi32 message("-- integer64 csv writes about 2x/0.5x faster than int64 (and about 1.5x/5x slower than integer) --") #tdfwI64/tdfwi64 tdfwi64/tdfwi32 message("-- integer64 csv reads about 3x/1.5 faster than int64 (and about 2x slower than integer) --") #tdfrI64/tdfri64 tdfri64/tdfri32 rm(i32, d64); gc() message("-- investigating the impact on garbage collection: --") message("-- the fragmented structure of int64 messes up R's RAM --") message("-- and slows down R's gargbage collection just by existing --") td32 <- double(21) td32[1] <- system.time(d64 <- double(1e7))[3] for (i in 2:11)td32[i] <- system.time(gc(), gcFirst=FALSE)[3] rm(d64) for (i in 12:21)td32[i] <- system.time(gc(), gcFirst=FALSE)[3] t64 <- double(21) t64[1] <- system.time(i64 <- integer64(1e7))[3] for (i in 2:11)t64[i] <- system.time(gc(), gcFirst=FALSE)[3] rm(i64) for (i in 12:21)t64[i] <- system.time(gc(), gcFirst=FALSE)[3] #T64 <- double(21) #T64[1] <- system.time(I64 <- int64(1e7))[3] #for (i in 2:11)T64[i] <- system.time(gc(), gcFirst=FALSE)[3] #rm(I64) #for (i in 12:21)T64[i] <- system.time(gc(), gcFirst=FALSE)[3] #matplot(1:21, cbind(td32, t64, T64), pch=c("d","i","I"), log="y") matplot(1:21, cbind(td32, t64), pch=c("d","i"), log="y") ## End(Not run)


Feel free to fill in the form or you can e-mail me at<EMAIL_ADDRESS>Download my CV here **Please note that at this time, the contact form is not yet working.


Stage 2 of 7
The address on your current driving licence
Select an address
Click on the box below, then select your address from the list
{{
Stage 2 of 7
The address on your current driving licence
Select an address
Click on the box below, then select your address from the list


{% extends "base.html" %} {% load i18n %} {% load crud_extras %} {% block body %}
{% trans "Do you really want to delete this record from the database?" %}
{% trans "Notice: this action cannot be undone!" %}


Hi Matthew Smith!
Welcome to Edtech Games!
We are happy you are here.
intense
engagement
Intense engagement enables intense learning!
Cutting
Edge Curriculum
Intense engagement allows us to pioneer more intense curriculum.
Vastly
Higher Efficacy
Higher Engagement + Better Curriculum = Vastly Higher Efficacy
© 2018 EDTECH GAMES, LLC


At the end of 6 months, you have raised a healthy baby who is now transitioning to solid foods. The path that you took to get this far is unique to you and you only. When all is said and done, you have given your child the best care that you could provide — love nurtures your child regardless of circumstances. We encourage you to play again as different mothers, to see how situations and options change for each mom.
We hope that after experiencing early motherhood in the shoes of 4 different mothers, you have come to realize the world of differences some have to face.
We hope you now have a better understanding of the choices that different moms can and cannot make. Having learned more about the difficulties that mothers have to face in order to breastfeed, consider donating to related non-profits or learning more via the Learn More button below.
US Breastfeeding Committee: A coalition of more than 100 organizations that support the mission to drive collaborative efforts for policy and practices that create a landscape of breastfeeding support across the United States.
La Leche League International: An international effort to help mothers breastfeed through mother-to-mother support, encouragement, information, and education, and to promote a better understanding of breastfeeding as an important element in the healthy development of the baby and mother.
Black Mothers’ Breastfeeding Association: A national non-profit organization that is focused on fostering a national impact on the reduction of racial disparities in breastfeeding success for black families.
HelpMe Feed: A mobile app developed for health professionals and mothers to improve global breastfeeding rates.
Fed Is Best: A foundation that works to identify critical gaps in current breastfeeding protocols, guidelines, and education programs. They do so by providing families and health professionals with the most up-to-date scientific research, education, and resources to practice safe infant feeding with breast milk, formula, or a combination of both.


This is an example of the "Sploit5-Grotesque5" web font file.
Note: Web Fonts may not work with all web browsers. Please check your web browser documentation for Web Font support.


PRIVACY POLICY FOR SUGARIZER
This privacy policy governs your use of the software application Sugarizer (“Application”) for mobile devices that was created by Lionel Laské. The Application is a learning platform coming with a set of activities for children.
What information does the Application obtain and how is it used?
Provided Information
The Application may collect certain information automatically, including, but not limited to, the type of mobile device you use, your mobile devices unique device ID, the IP address of your mobile device, your mobile operating system, the type of mobile Internet browsers you use, and information about the way you use the Application. However no personal or private information is collected by the Application.
Does the Application collect precise real time location information of the device?
This Application does not collect precise information about the location of your mobile device.
Do third parties see and/or have access to information obtained by the Application?
Only aggregated, anonymized data is periodically transmitted to external services to help us improve the Application and our service. We will not share your information with third parties.
What are my opt-out rights?
You can stop all collection of information by the Application easily by uninstalling the Application. You may use the standard uninstall processes as may be available as part of your mobile device or via the mobile application marketplace or network. You can also request to opt-out via email, at privacy@sugarizer.org.


An account groups financial records (e.g., a bank account). In the case of a bank account, the account has an owner, bank identification number, account number and a balance. For an account to exist, an access first has to be created. Then, an account resource can be queried for transactions, transaction patterns and summaries. Also, it is possible to transfer money from one account to another. AHOI allows you to give (user-defined) names to accounts to make them easily recognizable for end users. AHOIs automatic refresh of transactions and balances can also be toggled.
This endpoint handles the support of transaction categorization. Currently the one and only transaction categorization is the Finlytics method.
An analyzed contract list of current API user. Contracts will be identified by analyzing the account transactions.
The forecast resource provides a balance forecast for the end of the current month based on the current balance and the transaction patterns that are expected to occur up to the end of the current month. The upcoming transactions are also provided. The current month is determined by the latest refresh of transactions.
Providers represent financial institutions such as banks. They provide information such as the name of the provider and which institutions AHOI is able to access. A provider is the starting point to set up an access to a provider, to create accounts and to receive transactions.
A resouce to handle registration process via OAuth2. Fetch the API public key via GET /keys and registers the client using POST /registration
A security is a tradable financial asset. This part of the API is not final and subject to change.
TAN schemes are the available methods for authorizing a transfer.
Handling of asynchronous running tasks
A transaction represents a financial operation related to an account. A bank account transaction holds information about the debtor and the creditor, the amount, information about the date and time of booking, its availability and its purpose (as found in the memo field). Additionally, a transaction may be related to a recurring transaction pattern. The length of the transaction list depends on the provider and the amount of time in which the account has already been set up within AHOI. The provided information may differ from provider to provider.
Transaction patterns are the results of regularly recurring transactions. These patterns can be automatically recognized by AHOI. The recognition process starts after every account refresh and updates the previously discovered patterns. Since the process is not 100% accurate, single transaction patterns can be deactivated or can be created manually by the user. Transaction patterns are used to identify upcoming transactions and to calculate a balance forecast. They can be configured to be monthly, quarterly, semi-annually or annually recurring. To automatically create a transaction pattern, there has to be at least three transactions related to this pattern. One transaction pattern refers to many transactions and one account.
This resource returns a list of monthly summaries for an account for each month in which transactions are available. It contains balances and the total sum of incoming and outgoing transactions.
A endpoint for handling transfers.
An access represents the connection between a provider and an account. It enables AHOI to log into a (bank) account on behalf of a user. Setting up an access is relatively simple: A provider id is required, and the credential fields, which are used to access the provider, have to be set. The latter differ among the various providers. For example, for banks, it is common to use the account number and a secret pin. Other providers might use an e-mail address and a password. In a production environment, the pin has to be encrypted. Creating an access also allows AHOI to start interacting with the provider: It starts creating accounts, gathering transactions and classifying them. Deleting an access, on the other hand, also removes all associated information. Furthermore, an access contains important information about its current state — for example, whether the account has been locked.
https://banking-sandbox.starfinanz.de/ahoi/docs/api/swagger-ui/index.html#!/resource/Access


| Package | org.si.cml |
| Class | public class CMLObject |
| Inheritance | CMLObject org.si.cml.core.CMLListElem |
| Subclasses | ScopeLimitObject |
// Enemy class class Enemy extends CMLObject { ... // for initializing override public function onCreate() : void { _animationCounter = 0; } // for finalizing override public function onDestroy() : void { // destructionStatus=1 means destruction (as you like), create explosion particles. if (destructionStatus == 1) _createExplosion(); } // for updating on each frame override public function onUpdate() : void { // Increase animation counter. if (++_animationCounter == 100) _animationCounter = 0; // Drawing _drawEnemy(this); } // for new object created by "n" command override public function onNewObject(args:Array) : CMLObject { return new Enemy(); } // for new object created by "f" command override public function onFireObject(args:Array) : CMLObject { return new Bullet(); } ... } class Bullet extends CMLObject { ... } class Player extends CMLObject { ... } class Shot extends CMLObject { ... }
// 1st argument specifies scrolling direction (set true for vertical, false for horizontal). CMLObject.initialize(true);
var player:CMLObject = new Player(); // Player class is your extention of CMLObject. player.setAsDefaultTarget(); // Default target is the object to fire.
// Create stage sequence from "String of cannonML" or "XML of bulletML". var stageSequence:CMLSequence = new CMLSequence(String or XML); ... var root:Enemy = new Enemy(); // create one enemy as "root enemy" (usually transparent) root.create(x, y); // Create root enemy on the cml field. root.execute(stageSequence); // Execute stage sequence on root enemy.
addEventListener(Event.ENTER_FRAME, _onEnterFrame); function _onEnterFrame(event:Event) : void { CMLObject.update(); }
See also
| Property | Defined by | ||
|---|---|---|---|
| actor : * You can rewrite this for your own purpose.
| CMLObject | ||
| angle : Number Angle of this object, scrolling direction is 0 degree.
| CMLObject | ||
| angleAccel : Number [read-only] Calculate direction of accelaration.
| CMLObject | ||
| angleOnStage : Number Angle of this object, The direction(1,0) is 0 degree.
| CMLObject | ||
| angleParentOnStage : Number [read-only] Angle of this parent object, scrolling direction is 0 degree.
| CMLObject | ||
| anglePosition : Number [read-only] Calculate direction of position from origin.
| CMLObject | ||
| angleVelocity : Number [read-only] Calculate direction of velocity.
| CMLObject | ||
| destructionStatus : int [read-only] Destruction status.
| CMLObject | ||
| frameRateRatio : Number [static] Value of (frame rate to calculate speed) / (screen frame rate).
| CMLObject | ||
| funcRand : Function [static] Function for "$?/$??" variable, The type is function():Number.
| CMLObject | ||
| globalRank : Number [static] Variable for "$r"
| CMLObject | ||
| hasParts : Boolean [read-only] Does this object have another object as a part ?
| CMLObject | ||
| id : uint [read-only] Construction ID, this value changes when the object is destroyed.
| CMLObject | ||
| isActive : Boolean [read-only] Is this object on stage ?
| CMLObject | ||
| isPart : Boolean [read-only] Is this object a part of its parent ? The part object's position is relative to parent's position.
| CMLObject | ||
| motion_type : uint [read-only] Motion type.
| CMLObject | ||
| parent : CMLObject
[read-only] The CMLObject that creates this object.
| CMLObject | ||
| rank : Number You can define the "$r" value for each object by overriding this property, Ussualy returns CMLObject.globalRank.
| CMLObject | ||
| relatedX : Number [read-only] The x value of position parent related
| CMLObject | ||
| relatedY : Number [read-only] The y value of position parent related
| CMLObject | ||
| root : CMLObject
[static][read-only] root object is the default parent of all CMLObjects that are created with the argument of parent=null.
| CMLObject | ||
| scrollAngle : Number [static][read-only] Scrolling angle (vertical=-90, horizontal=180).
| CMLObject | ||
| velocity : Number Absolute value of velocity.
| CMLObject | ||
| vertical : int [static] Flag for scrolling direction (vertical=1, horizontal=0).
| CMLObject | ||
| vx : Number = 0 X value of velocity.
| CMLObject | ||
| vy : Number = 0 Y value of velocity.
| CMLObject | ||
| x : Number = 0 X value of position.
| CMLObject | ||
| y : Number = 0 Y value of position.
| CMLObject |
| Method | Defined by | ||
|---|---|---|---|
|
Constructor.
| CMLObject | ||
|
changeParent(parent_:CMLObject = null, isPart_:Boolean = false, access_id_:int):void
Change parent.
| CMLObject | ||
|
countAllIDedChildren():int
Count all children with access id.
| CMLObject | ||
|
countIDedChildren(id:int):int
Count children with specifyed id.
| CMLObject | ||
|
create(x_:Number, y_:Number, parent_:CMLObject = null, isPart_:Boolean = false, access_id_:int):CMLObject
Create new object on the CML stage.
| CMLObject | ||
|
destroy(status:int):void
Destroy this object.
| CMLObject | ||
|
destroyAll(status:int):void
[static] Destroy all active objects except for root.
| CMLObject | ||
|
Execute a sequence and create a new fiber.
| CMLObject | ||
|
findAllChildren(id:int, func:Function):int
Find all child and callback.
| CMLObject | ||
|
findAllParts(func:Function):int
Find all parts and callback.
| CMLObject | ||
|
Find first child object with specifyed id.
| CMLObject | ||
|
getAimingAngle(target_:CMLObject, offx:Number = 0, offy:Number = 0):Number
Calculate aiming angle to another object.
| CMLObject | ||
|
getDistance(tgt:CMLObject):Number
Calculate distance from another object aproximately.
| CMLObject | ||
|
halt():void
Destroy all fibers of this object.
| CMLObject | ||
|
initialize(vertical_:Boolean = true):CMLObject
[static] Call this function first of all.
| CMLObject | ||
|
onCreate():void
Callback function on create.
| CMLObject | ||
|
onDestroy():void
Callback function on destroy.
| CMLObject | ||
|
onFireObject(args:Array):CMLObject
Statement "f" calls this when it needs.
| CMLObject | ||
|
onNewObject(args:Array):CMLObject
Statement "n" calls this when it needs.
| CMLObject | ||
|
onUpdate():void
Callback function from CMLObject.update().
| CMLObject | ||
|
rand():Number
[static] The return value is from CMLObject.funcRand.
| CMLObject | ||
|
Reset position, velocity, accelaration, interpolation, motion type and rotation.
| CMLObject | ||
|
setAccelaration(ax_:Number, ay_:Number, time_:int = 0):CMLObject
Set accelaration.
| CMLObject | ||
|
Set as a default target object.
| CMLObject | ||
|
setChangeDirection(dir:Number, term:int, rmax:Number, shortest_rot:Boolean = true):CMLObject
<changeDirection type='absolute'> of bulletML.
| CMLObject | ||
|
setChangeSpeed(spd:Number, term:int = 0):CMLObject
<changeSpeed type='absolute'> of bulletML.
| CMLObject | ||
|
setConstantRotation(end_angle:Number, term:Number = 0, rmax:Number = 1, isShortestRotation:Boolean = true):CMLObject
Set constant rotation.
| CMLObject | ||
|
setGlobalRankRange(min:Number, max:Number):void
[static] Set the range of globalRank.
| CMLObject | ||
|
setGravity(atr_a:Number, atr_b:Number, term:int = 0):CMLObject
Set gravity motion.
| CMLObject | ||
|
setInterpolation(x_:Number, y_:Number, vx_:Number, vy_:Number, term_:int = 0):CMLObject
Set interpolating motion.
| CMLObject | ||
|
setPosition(x_:Number, y_:Number, term_:int = 0):CMLObject
Set position.
| CMLObject | ||
|
setRotation(end_angle:Number, term:Number = 0, start_t:Number = 1, end_t:Number = 1, isShortestRotation:Boolean = true):CMLObject
Set rotation.
| CMLObject | ||
|
setVelocity(vx_:Number, vy_:Number, term_:int = 0):CMLObject
Set velocity.
| CMLObject | ||
|
transformGlobalToLocal(global:Point):Point
transform global coordinate to object local coordinate
| CMLObject | ||
|
transformLocalToGlobal(local:Point):Point
transform object local coordinate to global coordinate
| CMLObject | ||
|
update():void
[static] Call this function for each frame.
| CMLObject |
| Method | Defined by | ||
|---|---|---|---|
|
calcAbsPosition():void
Calculate absolute position when the isPart is true.
| CMLObject | ||
|
calcRelatedPosition():void
Calculate parent related position from absolute position.
| CMLObject | ||
|
rotateHead():void
Rotate haed in 1 frame, if rotd > 0.
| CMLObject |
| Constant | Defined by | ||
|---|---|---|---|
| MT_ACCEL : uint = 1 [static] Number for CMLObject.motion_type, Accelarating motion.
| CMLObject | ||
| MT_BULLETML : uint = 3 [static] Number for CMLObject.motion_type, BulletML compatible motion.
| CMLObject | ||
| MT_CONST : uint = 0 [static] Number for CMLObject.motion_type, Linear motion.
| CMLObject | ||
| MT_GRAVITY : uint = 4 [static] Number for CMLObject.motion_type, Gravity motion.
| CMLObject | ||
| MT_INTERPOL : uint = 2 [static] Number for CMLObject.motion_type, 3D-Bezier interpolating motion.
| CMLObject | ||
| MT_PART_ACCEL : uint [static] Number for CMLObject.motion_type, Accelarating motion of parts.
| CMLObject | ||
| MT_PART_BULLETML : uint [static] Number for CMLObject.motion_type, BulletML compatible motion of parts.
| CMLObject | ||
| MT_PART_CONST : uint [static] Number for CMLObject.motion_type, Linear motion of parts.
| CMLObject | ||
| MT_PART_INTERPOL : uint [static] Number for CMLObject.motion_type, 3D-Bezier interpolating motion of parts.
| CMLObject |
| actor | property |
public var actor:*
You can rewrite this for your own purpose.
| angle | property |
angle:Number
[read-write]Angle of this object, scrolling direction is 0 degree.
Implementation public function get angle():Number
public function set angle(value:Number):void
| angleAccel | property |
angleAccel:Number
[read-only]Calculate direction of accelaration.
Implementation public function get angleAccel():Number
| angleOnStage | property |
angleOnStage:Number
[read-write]Angle of this object, The direction(1,0) is 0 degree.
Implementation public function get angleOnStage():Number
public function set angleOnStage(value:Number):void
| angleParentOnStage | property |
angleParentOnStage:Number
[read-only]Angle of this parent object, scrolling direction is 0 degree.
Implementation public function get angleParentOnStage():Number
| anglePosition | property |
anglePosition:Number
[read-only]Calculate direction of position from origin.
Implementation public function get anglePosition():Number
| angleVelocity | property |
angleVelocity:Number
[read-only]Calculate direction of velocity.
Implementation public function get angleVelocity():Number
| destructionStatus | property |
destructionStatus:int
[read-only]Destruction status. You can refer the argument of destroy() or the '
Implementation public function get destructionStatus():int
See also
| frameRateRatio | property |
frameRateRatio:Number
[read-write]Value of (frame rate to calculate speed) / (screen frame rate).
Implementation public static function get frameRateRatio():Number
public function set frameRateRatio(value:Number):void
| funcRand | property |
funcRand:Function
[read-write]Function for "$?/$??" variable, The type is function():Number.
The default value is Math.random()
.
public static function get funcRand():Function
public function set funcRand(value:Function):void
| globalRank | property |
globalRank:Number
[read-write]Variable for "$r"
Implementation public static function get globalRank():Number
public function set globalRank(value:Number):void
| hasParts | property |
hasParts:Boolean
[read-only]Does this object have another object as a part ?
Implementation public function get hasParts():Boolean
| id | property |
id:uint
[read-only]Construction ID, this value changes when the object is destroyed.
Implementation public function get id():uint
target_object_id = target_object.id; // keep the target's id value. ... if (target_object_id != target_object.id) { // if the id value is different, target_object = null; // target object was destroyed. }
| isActive | property |
isActive:Boolean
[read-only]Is this object on stage ?
Implementation public function get isActive():Boolean
| isPart | property |
isPart:Boolean
[read-only]Is this object a part of its parent ? The part object's position is relative to parent's position.
Implementation public function get isPart():Boolean
| motion_type | property |
motion_type:uint
[read-only]Motion type.
Implementation public function get motion_type():uint
See also
| parent | property |
parent:CMLObject
[read-only]The CMLObject that creates this object. Returns root when the parent was destroyed.
Implementation public function get parent():CMLObject
| rank | property |
rank:Number
[read-write]You can define the "$r" value for each object by overriding this property, Ussualy returns CMLObject.globalRank.
Implementation public function get rank():Number
public function set rank(value:Number):void
See also
| relatedX | property |
relatedX:Number
[read-only]The x value of position parent related
Implementation public function get relatedX():Number
| relatedY | property |
relatedY:Number
[read-only]The y value of position parent related
Implementation public function get relatedY():Number
| root | property |
root:CMLObject
[read-only]root object is the default parent of all CMLObjects that are created with the argument of parent=null.
Implementation public static function get root():CMLObject
| scrollAngle | property |
scrollAngle:Number
[read-only]Scrolling angle (vertical=-90, horizontal=180).
Implementation public static function get scrollAngle():Number
| velocity | property |
velocity:Number
[read-write]Absolute value of velocity.
Implementation public function get velocity():Number
public function set velocity(value:Number):void
| vertical | property |
vertical:int
[read-write]Flag for scrolling direction (vertical=1, horizontal=0).
Implementation public static function get vertical():int
public function set vertical(value:int):void
| vx | property |
public var vx:Number = 0
X value of velocity.
| vy | property |
public var vy:Number = 0
Y value of velocity.
| x | property |
public var x:Number = 0
X value of position.
| y | property |
public var y:Number = 0
Y value of position.
| CMLObject | () | constructor |
public function CMLObject()
Constructor.
| calcAbsPosition | () | method |
protected function calcAbsPosition():void
Calculate absolute position when the isPart is true. The protected function _motion_parts() is a typical usage of this.
| calcRelatedPosition | () | method |
protected function calcRelatedPosition():void
Calculate parent related position from absolute position.
| changeParent | () | method |
public function changeParent(parent_:CMLObject = null, isPart_:Boolean = false, access_id_:int):void
Change parent.
Parametersparent_:CMLObject (default = null )
|
|
isPart_:Boolean (default = false )
|
|
access_id_:int |
| countAllIDedChildren | () | method |
public function countAllIDedChildren():int
Count all children with access id.
Returnsint — The count of child objects with access id.
|
See also
| countIDedChildren | () | method |
public function countIDedChildren(id:int):int
Count children with specifyed id.
Parametersid:int — Access id specifyed in create() or "n command.
|
int — The count of child objects with specifyed id.
|
See also
| create | () | method |
public function create(x_:Number, y_:Number, parent_:CMLObject = null, isPart_:Boolean = false, access_id_:int):CMLObject
Create new object on the CML stage.
Parametersx_:Number — X value of this object on a stage or parent(if its a part of parent).
|
|
y_:Number — Y value of this object on a stage or parent(if its a part of parent).
|
|
parent_:CMLObject (default = null ) — The instance of parent object. Pass null to set this object as a child of root.
|
|
isPart_:Boolean (default = false ) — True to set this object as a part of parent.
|
|
access_id_:int — Access ID from parent.
|
CMLObject —
this instance.
|
| destroy | () | method |
public function destroy(status:int):void
Destroy this object. The onDestroy() is called when the next CMLObject.update().
Parametersstatus:int — A value of the destruction status. This must be greater than or equal to 0. You can refer this by CMLObject.destructionStatus in onDestroy().
|
See also
| destroyAll | () | method |
public static function destroyAll(status:int):void
Destroy all active objects except for root. This function must not be called from onDestroy().
Parametersstatus:int — A value of the destruction status. This must be greater than or equal to 0. You can refer this by destructionStatus in onDestroy().
|
See also
| execute | () | method |
public function execute(seq:CMLSequence, args:Array = null, invertFlag:uint = 0):CMLFiber
Execute a sequence and create a new fiber.
Parametersseq:CMLSequence — The sequence to execute.
|
|
args:Array (default = null ) — The array of arguments to execute sequence.
|
|
invertFlag:uint (default = 0 ) — The flag to invert execution same as 'm' command.
|
CMLFiber —
Instance of fiber that execute the sequence.
|
| findAllChildren | () | method |
public function findAllChildren(id:int, func:Function):int
Find all child and callback.
id:int — Access id specifyed in create() or "n command.
|
|
func:Function — The call back function to operate objects. The type is function(obj:CMLObject):Boolean. Stop finding when this returns true.
|
int — The count of the executions of call back function.
|
See also
| findAllParts | () | method |
public function findAllParts(func:Function):int
Find all parts and callback.
func:Function — The call back function to operate objects. The type is function(obj:CMLObject):Boolean. Stop finding when this returns true.
|
int — The count of the executions of call back function.
|
See also
| findChild | () | method |
public function findChild(id:int):CMLObject
Find first child object with specifyed id.
Parametersid:int — Access id specifyed in create() or "n command.
|
CMLObject —
The first child object with specifyed id. Return null when the seach was failed.
|
See also
| getAimingAngle | () | method |
public function getAimingAngle(target_:CMLObject, offx:Number = 0, offy:Number = 0):Number
Calculate aiming angle to another object.
Parameterstarget_:CMLObject — Another object to calculate angle.
|
|
offx:Number (default = 0 ) — X position offset to calculate angle.
|
|
offy:Number (default = 0 ) — Y position offset to calculate angle.
|
Number — Angle.
|
| getDistance | () | method |
public function getDistance(tgt:CMLObject):Number
Calculate distance from another object aproximately. The distance is calculated as an octagnal.
Parameterstgt:CMLObject — Another object to calculate distance.
|
Number — Rough distance.
|
| halt | () | method |
public function halt():void
Destroy all fibers of this object. This function is slow. If you want to execute faster, keep returned CMLFiber of CMLObject.execute() and call CMLFiber.destroy() wherever possible.
See also
| initialize | () | method |
public static function initialize(vertical_:Boolean = true):CMLObject
Call this function first of all.
Parametersvertical_:Boolean (default = true ) — Flag of scrolling direction
|
CMLObject —
The root object.
|
| onCreate | () | method |
public function onCreate():void
Callback function on create. Override this to initialize.
| onDestroy | () | method |
public function onDestroy():void
Callback function on destroy. Override this to finalize.
See also
| onFireObject | () | method |
public function onFireObject(args:Array):CMLObject
Statement "f" calls this when it needs. Override this to define the new CMLObject created by "f" command.
Parametersargs:Array — The arguments of sequence.
|
CMLObject —
The new CMLObject created by "n" command. You must not activate(call create()) returning CMLObject.
|
| onNewObject | () | method |
public function onNewObject(args:Array):CMLObject
Statement "n" calls this when it needs. Override this to define the new CMLObject created by "n" command.
Parametersargs:Array — The arguments of sequence.
|
CMLObject —
The new CMLObject created by "n" command. You must not activate(call create()) returning CMLObject.
|
| onUpdate | () | method |
public function onUpdate():void
Callback function from CMLObject.update(). This function is called after updating position. Override this to update own parameters.
| rand | () | method |
public static function rand():Number
The return value is from CMLObject.funcRand. Call CMLObject.funcRand internally.
ReturnsNumber — The random number between 0-1.
|
See also
| reset | () | method |
public function reset(x_:Number, y_:Number):CMLObject
Reset position, velocity, accelaration, interpolation, motion type and rotation.
Parametersx_:Number |
|
y_:Number |
CMLObject |
| rotateHead | () | method |
protected function rotateHead():void
Rotate haed in 1 frame, if rotd > 0. The _motion() is a typical usage exapmle.
See also
| setAccelaration | () | method |
public function setAccelaration(ax_:Number, ay_:Number, time_:int = 0):CMLObject
Set accelaration.
Parametersax_:Number — X value of accelaration.
|
|
ay_:Number — Y value of accelaration.
|
|
time_:int (default = 0 ) — Frames to stop accelarate. 0 means not to stop.
|
CMLObject —
this object
|
| setAsDefaultTarget | () | method |
public function setAsDefaultTarget():CMLObject
Set as a default target object. A default target is the object to target from all objects at default, usually player is as.
ReturnsCMLObject —
this object
|
| setChangeDirection | () | method |
public function setChangeDirection(dir:Number, term:int, rmax:Number, shortest_rot:Boolean = true):CMLObject
<changeDirection type='absolute'> of bulletML.
Parametersdir:Number — Direction to change.
|
|
term:int — Frames to change direction.
|
|
rmax:Number — Maxmum speed of rotation [degrees/frame].
|
|
shortest_rot:Boolean (default = true ) — Flag to rotate on shortest rotation.
|
CMLObject —
this object
|
| setChangeSpeed | () | method |
public function setChangeSpeed(spd:Number, term:int = 0):CMLObject
<changeSpeed type='absolute'> of bulletML.
Parametersspd:Number — Speed to change.
|
|
term:int (default = 0 ) — Frames to change speed.
|
CMLObject —
this object
|
| setConstantRotation | () | method |
public function setConstantRotation(end_angle:Number, term:Number = 0, rmax:Number = 1, isShortestRotation:Boolean = true):CMLObject
Set constant rotation. You can specify the maximum speed.
Parametersend_angle:Number — Final angle when the rotation finished, based on scrolling direction.
|
|
term:Number (default = 0 ) — Frames to rotate.
|
|
rmax:Number (default = 1 ) — Maximum speed of rotation [degrees/frame].
|
|
isShortestRotation:Boolean (default = true ) — Rotate with shortest rotation or not.
|
CMLObject —
this object
|
| setGlobalRankRange | () | method |
public static function setGlobalRankRange(min:Number, max:Number):void
Set the range of globalRank. The global rank value is limited in this range.
Parametersmin:Number |
|
max:Number |
| setGravity | () | method |
public function setGravity(atr_a:Number, atr_b:Number, term:int = 0):CMLObject
Set gravity motion.
This function is not available for a part of parent.
After this function, the CMLObject.setPosition() sets the gravity center.
The calculation of the motion is below.
[accelaration] = [distance] [atr_a] / 100 - [velocity] [atr_b] / 100
atr_a:Number — Attracting parameter a[%]. Ratio of attracting force.
|
|
atr_b:Number — Attracting parameter b[%]. Ratio of air fliction.
|
|
term:int (default = 0 ) — Frames to enable attracting force.
|
CMLObject —
this object
|
See also
| setInterpolation | () | method |
public function setInterpolation(x_:Number, y_:Number, vx_:Number, vy_:Number, term_:int = 0):CMLObject
Set interpolating motion.
Parametersx_:Number — X value of position.
|
|
y_:Number — Y value of position.
|
|
vx_:Number — X value of velocity.
|
|
vy_:Number — Y value of velocity.
|
|
term_:int (default = 0 ) — Frames for tweening with bezier interpolation.
|
CMLObject —
this object
|
| setPosition | () | method |
public function setPosition(x_:Number, y_:Number, term_:int = 0):CMLObject
Set position.
Parametersx_:Number — X value of position.
|
|
y_:Number — Y value of position.
|
|
term_:int (default = 0 ) — Frames for tweening with bezier interpolation.
|
CMLObject —
this object
|
| setRotation | () | method |
public function setRotation(end_angle:Number, term:Number = 0, start_t:Number = 1, end_t:Number = 1, isShortestRotation:Boolean = true):CMLObject
Set rotation. You can specify the first and last speed.
Parametersend_angle:Number — Final angle when the rotation finished, based on scrolling direction.
|
|
term:Number (default = 0 ) — Frames to rotate.
|
|
start_t:Number (default = 1 ) — Ratio of first rotating speed. The value of 1 means the speed of a constant rotation.
|
|
end_t:Number (default = 1 ) — Ratio of last rotating speed. The value of 1 means the speed of a constant rotation.
|
|
isShortestRotation:Boolean (default = true ) — Rotate with shortest rotation or not.
|
CMLObject —
this object
|
| setVelocity | () | method |
public function setVelocity(vx_:Number, vy_:Number, term_:int = 0):CMLObject
Set velocity.
Parametersvx_:Number — X value of velocity.
|
|
vy_:Number — Y value of velocity.
|
|
term_:int (default = 0 ) — Frames for tweening with bezier interpolation.
|
CMLObject —
this object
|
| transformGlobalToLocal | () | method |
public function transformGlobalToLocal(global:Point):Point
transform global coordinate to object local coordinate
Parametersglobal:Point — on global coordinate. this instance is overwritten inside.
|
Point — point on local coordinate. this instance is that you passed as argument.
|
| transformLocalToGlobal | () | method |
public function transformLocalToGlobal(local:Point):Point
transform object local coordinate to global coordinate
Parameterslocal:Point — on local coordinate. this instance is overwritten inside.
|
Point — point on global coordinate. this instance is that you passed as argument.
|
| update | () | method |
public static function update():void
Call this function for each frame. This function calls all CMLObject.onUpdate()s.
| MT_ACCEL | constant |
public static const MT_ACCEL:uint = 1
Number for CMLObject.motion_type, Accelarating motion.
| MT_BULLETML | constant |
public static const MT_BULLETML:uint = 3
Number for CMLObject.motion_type, BulletML compatible motion.
| MT_CONST | constant |
public static const MT_CONST:uint = 0
Number for CMLObject.motion_type, Linear motion.
| MT_GRAVITY | constant |
public static const MT_GRAVITY:uint = 4
Number for CMLObject.motion_type, Gravity motion.
| MT_INTERPOL | constant |
public static const MT_INTERPOL:uint = 2
Number for CMLObject.motion_type, 3D-Bezier interpolating motion.
| MT_PART_ACCEL | constant |
public static const MT_PART_ACCEL:uint
Number for CMLObject.motion_type, Accelarating motion of parts.
| MT_PART_BULLETML | constant |
public static const MT_PART_BULLETML:uint
Number for CMLObject.motion_type, BulletML compatible motion of parts.
| MT_PART_CONST | constant |
public static const MT_PART_CONST:uint
Number for CMLObject.motion_type, Linear motion of parts.
| MT_PART_INTERPOL | constant |
public static const MT_PART_INTERPOL:uint
Number for CMLObject.motion_type, 3D-Bezier interpolating motion of parts.


{% verbatim %}
Hi {{user_data.username}}, your session cookie is: {{ user_data.session_cookie }}. This website collects cookies. Please accept the terms and conditions by pressing the ACCEPT button to continue viewing memes.


If you are a student looking for a job or applying to graduate school, you will find that you need to ask one or more professors for letters of recommendation, or at least for the right to list one of us as a reference on your resume. Asking a professor for this favor can feel intimidating, but you should know that most of us view this task as part of our job description. (While writing letters is part of our job description, writing positive letters for every single student who asks is not.)
Here are some heuristics for getting a good letter of recommendation:
Stand out from the crowd. All employers and graduate schools want to attract special people, and so you want your letters to provide evidence of that. Simply getting good grades on your homework assignments and tests is not, unfortunately, the ticket to a recommendation letter that stands out from the crowd. If the only thing I can say in my letter is that you turned in your assignments on time and received an A in the class, that will be received as a lukewarm endorsement at best.
To get a good recommendation letter, you need to do something beyond simply attending class and getting a decent grade. Some students have done that by taking a leadership role in the class and going above and beyond the minimal requirements. Others have continued on and taken independent study classes. Still others have done an Honors Thesis, or volunteered in my research group. For all of those students, I can write a recommendation letter that goes into specifics about what they have accomplished working directly with me outside the normal classroom environment. In one case, I wrote an enthusiastic letter of recommendation for a student who received a low grade in my class because he convinced me from his additional activities that this grade was not indicative of his capabilities.
Create a high quality professional portfolio, and keep it up to date. I teach a lot of students, and sometimes several years might pass before you find the need to ask me for a letter of recommendation. One of the many virtues of a professional portfolio is that it can help refresh my memory about your accomplishments in my class, as well as inform me of any additional accomplishments since that time. Before contacting me, review your professional portfolio and make it as polished and up to date as possible. If I am impressed by your portfolio, it is much easier for me to write an impressive letter of recommendation.
If your professional portfolio includes no new projects or essays since my class, then it is harder for me to write you a really good letter of recommendation. My best recommendation letters have the form: “This student did well in my class, but I am particularly impressed by their accomplishments afterwards…”, where I continue with a description of what you did since my class. Note that for me to write this kind of letter effectively, I need more than a resume or LinkedIn profile from you, since those only contain bullet points. Instead, I need the kind of long-form description available in a portfolio, where you can provide detailed information about projects and/or essays discussing, for example, your perspectives on leadership.
Waive your right of access to the letters of recommendation. Whenever a school requests letters of recommendation, you must indicate whether or not you are willing to waive your right to see the letters. While curiosity (or fear) might tempt you to not waive the right, resist this feeling. If a school knows that you have retained the right to review the letters, then the letters have significantly less impact. As someone who reviews applications to our graduate program, I am not confident that the recommending letter is completely “honest” when I see that the student has retained the right to view it. Even worse, I wonder if the student has solicited letters previously, then selected only the positive ones to forward on.
A better way to go is to ask the potential recommender: “Are you able to write me a positive letter of recommendation?” I know of no one (at least on the ICS faculty) who would lie in response to that question. Either they will say, “Yes”, or they will say something like, “Well, I really didn’t have enough interaction with you to write something good, do you work with another faculty member more closely?”, or even, “I’m really sorry, I’m very busy with other duties right now, I don’t think I can do it in a timely manner.”
Consider setting up a credentials file at Student Services. If you are applying to lot of jobs, it can be useful to set up a credential file. Using this mechanism, I can write a single letter of recommendation, and you can get it sent to as many potential employers as you like, for as long as you like. Those letters tend to be somewhat more generic, but the advantage is that you have easy access. Note that some programs, such as the ICS graduate program, have specific forms that need to be filled out so you cannot use the credentials service in all cases.
Here’s how to request a letter from me. This also works pretty well for other faculty members.
Update your professional portfolio, or create one if you don’t have one already. To write you a decent letter, I need to be reminded of your background.
If you are going to ask me for a generic letter of recommendation, go to Career Services, and set up a confidential credential file. (I do not write “open” letters of recommendation, since they are generally useless in the job market.)
If you are applying to places that have specific forms or submission instructions, do research on what is needed and assemble all materials I will need to complete the recommendation.
Once you have completed the above, send me an email asking if I can write you a letter of recommendation. Provide me with a link to your updated professional portfolio site. Remind me of all the classes you took from me, the semester you took them from me, and what grade you received. If there are deadlines I should be aware of, please let me know. Let me know if you need a letter for a specific program (such as the ICS graduate program) or a generic letter for Career Services, or both. I will reply to let you know if I am able to write you a letter.
If I reply positively, then if you are requesting a generic letter, print out and fill out the “Instructions for authors of credential letters”, and drop it off in my mailbox in the ICS Office (POST 302). If you also need physical letters for specific programs, print out the forms (if hardcopy) and put them in my mailbox as well. Send me an email indicating that you have dropped these materials off in my mailbox. If you want me to upload a letter to an online service, then provide me with details in your email. Note: please make the process clear and straightforward for me. Don’t expect me to figure out your deadlines, or what services I am supposed to use on your behalf. I want to help you but you need to do your part.
When I have written the letter(s), I will reply to your email and let you know that I’ve done so.
Good luck with your future endeavors, and I hope that we in the ICS Department have provided what you need for a happy and prosperous future.


API
Not Found
We're now fixing this problem, sorry for the inconveniences.
Please request properly.
hilaolustudio API Framework


Before Change
return [self.image_name]
def visible_settings(self):
return [self.image_name, self.remove_button]
self.image_groups.append(ImageSettings(self.image_groups))
def add_object_cb(self):
Add a slot for another object
class ObjectSettings(object):
After Change
return result
def add_image_cb(self):
group = cps.SettingsGroup()
group.append("image_name",
cps.ImageNameSubscriber("Select an input image","None",
doc=What did you call the greyscale images you want to measure?))
group.append("remover", cps.RemoveSettingButton("", "Remove above image", self.image_groups, group))
self.image_groups.append(group)
def add_object_cb(self):
Add a slot for another object
group = cps.SettingsGroup()


please select
{{city}}
{{my_city}}
let's see the expression {{1+2}}
The style sheet should be changed
Click Me


{{ partial "head.html" . }}
{{ partial "nav.html" . }}
{{ partial "banner.html" . }} {{ partial "feature_case_client.html" . }} {{ partial "statistics.html" . }} {{ partial "calendar.html" . }} {{ partial "action.html" . }} {{ partial "video_show.html" . }} {{ partial "partnerShip.html" . }} {{ partial "organization.html" . }} {{ partial "communityPartner.html" . }}
{{ partial "footer.html" . }}
{{ partial "scripts.html" . }}


Light Pipelines#
LightPipeline is a Spark NLP specific Pipeline class equivalent to the Spark ML Pipeline. The difference is that it’s execution does not hold to Spark principles, instead it computes everything locally (but in parallel) in order to achieve fast results when dealing with small amounts of data.
This means, we do not input a Spark Dataframe, but a string or an Array of strings
instead, to be annotated. To create Light Pipelines, you need to input an already
trained (fit) Spark ML Pipeline. It’s transform()
stage is converted into
annotate()
instead.
Converting PipelineModels#
For example, the pipeline defined in the last section Setting up your own pipeline can be converted into a LightPipeline:
>>> from sparknlp.base import LightPipeline
>>> light = LightPipeline(pipeline.fit(data))
>>> light.annotate("We are very happy about Spark NLP")
{'token': ['We', 'are', 'very', 'happy', 'about', 'Spark', 'NLP']}
Pretrained Light Pipelines#
PretrainedPipelines have a LightPipeline component and therefore have an interface for annotate()
:
>>> from sparknlp.pretrained import PretrainedPipeline
>>> explain_document_pipeline = PretrainedPipeline("explain_document_ml")
explain_document_ml download started this may take some time.
Approx size to download 9.1 MB
[OK!]
>>> explain_document_pipeline.annotate("We are very happy about Spark NLP")
{'document': ['We are very happy about Spark NLP'],
'lemmas': ['We', 'be', 'very', 'happy', 'about', 'Spark', 'NLP'],
'pos': ['PRP', 'VBP', 'RB', 'JJ', 'IN', 'NNP', 'NNP'],
'sentence': ['We are very happy about Spark NLP'],
'spell': ['We', 'are', 'very', 'happy', 'about', 'Spark', 'NLP'],
'stems': ['we', 'ar', 'veri', 'happi', 'about', 'spark', 'nlp'],
'token': ['We', 'are', 'very', 'happy', 'about', 'Spark', 'NLP']}


Enter Your Name
Select Your Sex
MALE |
FEMALE |
TRANSGENDER
Select Your Hobbies
SPORTS |
READING |
BIKING |
CODING


A Tribute to Zhou Youguang
The Father of Pinyin
Zhou in 2012 (image credit: Wikipedia)
Zhou Youguang (1906-2017) was a Chinese linguist, writer, and sometime dissident, among other things. The achievement he is most famous for is the invention of Pinyin, a transliteration/romanization system for the Chinese language. When you read words like "Beijing" or "feng shui", you're reading Pinyin.
Hover or tap any of the underlined words on this page to view the Chinese characters and Pinyin.
A timeline of Zhou Youguang's life:
- 1906Born in Changzhou, Jiangsu province.
- 1927Graduates from Guanghua University.
- 1933Marries his wife, Zhang Yunhe, and moves to Japan for his studies.
- 1937Due to the outbreak of the Second Sino-Japanese War, moves back to China, this time to Chongqing. His daughter dies.
- 1945Japan is defeated. Zhou works abroard with Sin Hua Bank in New York and London.
- 1955The Chinese Communist Party places him at the head of a language-reform comittee. During this time, he works on developing Pinyin.
- 1958Pinyin starts being promoted as the official romanization for Chinese.
- 196?Branded a counterrevolutionary and sent to the countryside for "reeducation" during the Cultural Revolution.
- 1980Starts working on translating the Encyclopædia Britannica into Chinese.
- 2000Starts work on the first of ten books on a variety of subjects.
- 2011Controversially criticizes former paramount leader Deng Xiaoping in an interview with NPR.
- 2017Dies at his home in Beijing. He was 111 years and 1 day old, and had outlived both his wife and his son.
Learn more:


It’s raining on our Picnik!
Photo editing made fun
Picnik makes your photos fabulous with easy to use yet powerful editing tools. Tweak to your heart’s content, then get creative with oodles of effects, fonts, shapes, and frames.
It's fast, easy, and fun.
- Fix your photos in just one click
- Use advanced controls to fine-tune your results
- Crop, resize, and rotate in real-time
- Tons of special effects, from artsy to fun
- Astoundingly fast, right in your browser
- Awesome fonts and top-quality type tool
- Basketfuls of shapes from hand-picked designers
- Works on Mac, Windows, and Linux
- No download required, nothing to install
- All this for free! Want more? Upgrade to
Picnik Premium for only $24.95 a year!