Docile
Exported
meta()
Add additional metadata to a documented object.
meta
takes arbitrary keyword arguments and stores them internally as a
Dict{Symbol,Any}
. The optional doc
argument defaults to an empty string if
not specified.
Examples:
The syntax previously used (in versions prior to 0.3.2
) was
@doc "Documentation goes here..." [ :returns => (Int,) ] ->
foobar(x) = 2x + 1
This now becomes
@doc meta("Documentation goes here...", returns = (Int,)) ->
foobar(x) = 2x + 1
Specifying an external file as documentation can be done in the following way:
@doc meta(file = "../my/external/file.md") ->
foobar(x) = 2x + 1
Note: the file
path is relative to the current source file.
source: Docile/src/docstrings.jl:86
meta(doc)
Add additional metadata to a documented object.
meta
takes arbitrary keyword arguments and stores them internally as a
Dict{Symbol,Any}
. The optional doc
argument defaults to an empty string if
not specified.
Examples:
The syntax previously used (in versions prior to 0.3.2
) was
@doc "Documentation goes here..." [ :returns => (Int,) ] ->
foobar(x) = 2x + 1
This now becomes
@doc meta("Documentation goes here...", returns = (Int,)) ->
foobar(x) = 2x + 1
Specifying an external file as documentation can be done in the following way:
@doc meta(file = "../my/external/file.md") ->
foobar(x) = 2x + 1
Note: the file
path is relative to the current source file.
source: Docile/src/docstrings.jl:86
@comment(text)
Add additional commentary to source code unrelated to any particular object.
Example:
@comment """
...
"""
signature: comment(text)
source: Docile/src/docstrings.jl:51
@doc(args...)
Document objects in source code such as functions, methods, macros, types, globals, and modules.
Takes a string as documentation or a meta
object containing a docstring and/or
additional metadata. See meta
for further details.
Examples:
@docstrings
@doc "A single line method docstring with no metadata." ->
f(x) = x
@doc meta("A single line macro docstring with some arbitrary metadata.",
author = "Author Name") ->
macro g(x)
x
end
@doc """
A longer docstring for a type in a triple quoted string with no metadata.
""" ->
type F
# ...
end
@doc meta("""
A triple quoted docstring for a global with metadata.
""", status = (:deprecated, v"0.1.0")) ->
const ABC = 1
value = "interpolated"
@doc """
Since docstrings are just normal strings values can be $(value) into
them from the surrounding scope or calculated, $(rand()), when the
module is loaded.
""" ->
immutable G
# ...
end
Documenting Functions and Methods
Adding documentation to a Function
rather than a specific Method
can be
achieved in two ways.
Case 1
Documentation may be added after the first definition of a method. In the
following example documentation is added to the method f(x)
and then to the
generic function f
.
@doc "Method specific documentation." ->
function f(x)
x
end
@doc "Documentation for generic function `f`." -> f
Note: The f
may be written directly after the ->
or on the subsequent
line.
Case 2
There may only be generic documentation for a function and none that is
method-specific. In this case the generic documentation may be written directly
above one of the methods by using @doc*
. The documentation will then be
associated with the Function
object rather than that particular Method
.
@doc* "Generic documentation for this function." ->
function f(x)
x
end
Documentation Formatting and Interpolation
Currently the only supported format for docstrings is markdown as provided by the Markdown.jl package.
By default all docstrings will be stored in Docs{:md}
types. This default may
be changed (once other formats become available) using the @docstring
macro
metadata (see @docstrings for details).
Since $
and \
are not interpreted literally in strings, string macros
@md_str
and @md_mstr
are provided to make it easier to enter LaTeX equations
in docstrings. The @md_str entry provides details.
signature: doc(args...)
source: Docile/src/macros.jl:234
@docstrings(args...)
Module documentation initialiser. Optional.
The macro creates the required Documentation
object used to store a module's
docstrings. When no @docstrings
in provided the first @doc
usage will
automatically generate the required Documentation
object without additional
metadata.
Example:
using Docile
@docstrings(manual = ["../doc/manual.md"])
Available keywords are manual
and format
. Others will become available in
the future.
format
specifies the default format to use for all docstrings in a module.
:md
is the default format.
manual
is a vector of files that make up a module's manual section. The paths
must be specified relative to the source file where @docstrings
is called
from.
The manual sections may be viewed using the manual
function from
Lexicon.jl and are included in
the HTML documentation generated by Lexicon.
signature: docstrings(args...)
source: Docile/src/macros.jl:135
@document(options...)
Macro used to setup documentation for the current module.
Keyword arguments may be given to either override default module-level metadata or to provide additional key/value pairs.
Examples:
using Docile
@document
using Docile
@document(manual = ["../docs/manual.md"])
signature: document(options...)
source: Docile/src/Docile.jl:92
@file_str(path)
Provide a file path to the contents of a docstring.
The path is relative to the current source code file where the macro is called
from. The docstring format is decided based on the file extension provided. For
files written in markdown the extension must be .md
.
Example:
file"../docs/foobar.md"
foobar(x) = 2x
signature: file_str(path)
source: Docile/src/docstrings.jl:35
Internal
addentry!
Add object or set of objects and corresponding Entry
object to a module.
source: Docile/src/builddocs.jl:92
Docs(data::String)
Lazy obj
field access which leaves the obj
field undefined until first accessed.
source: Docile/src/types.jl:21
Docs(docs::Docs{format})
Pass Doc
objects straight through. Simplifies code in Entry
constructors.
source: Docile/src/types.jl:24
Docs(file::File)
Read a file's contents as the docstring.
source: Docile/src/types.jl:27
Entry(modname::Module, source, doc::Docs{format})
For md"" etc. -style docstrings.
source: Docile/src/types.jl:82
Entry(modname::Module, source, doc::String)
Convenience constructor for simple string docs.
source: Docile/src/types.jl:75
Entry(modname::Module, source, tup::(Any..., ))
Handle the meta
method syntax for @doc
.
source: Docile/src/types.jl:61
Manual(::Nothing, files)
Usage from REPL, use current directory as root.
source: Docile/src/types.jl:107
Metadata(root::String, data::Dict{K, V})
Convenience constructor for Metadata
type that initializes default values for
most of the type's fields.
source: Docile/src/Docile.jl:45
builddocs!(meta)
Parse root
and files
, adding available docstrings to objects
.
source: Docile/src/builddocs.jl:7
docstar(symb::Symbol, args...)
Attaching metadata to the generic function rather than the specific method which
the @doc
is applied to.
source: Docile/src/macros.jl:83
exec(state::State, ex::Expr)
Execute expression ex
in the context provided by state
.
Given an Expr
and an a State
object we walk the expression tree replacing
symbols with their actual values as determined by the provided state
variable.
This method's main purpose is to evaluate method signatures and is not
designed to act as a replacement for eval
in any way.
Some expression classes that exec
should be able to interpret are:
- Symbols defined in a module or scope provided by the
state
object. - Qualified names, ie.
MyModule.foo
. - Method and macro calls.
- Type parameters.
- Vararg syntax.
- Tuples and vectors (both
hcat
andvcat
). - Basic indexing syntax with unnested
end
and:
. - String interpolation.
:
range syntax (botha:b
anda:b:c
).$
interpolation for simple@eval
-style code generation in for-loops.- Constants.
Example:
vec = [1, 2, 3]
state = Docile.State(current_module())
Docile.exec(state, :(vec[1:2]))
Docile.exec(state, :(1 + 2 + 3))
Docile.exec(state, :("This is a vector: $(vec)"))
Docile.exec(state, :(Union(Vector{Int}, Array{Float64, 3})))
source: Docile/src/method-lookup.jl:139
externaldocs(mod, meta)
Guess doc format from file extension. Entry docstring created when file does not exist.
source: Docile/src/types.jl:34
findmethods(state::State, ex::Expr)
Return set of methods defined by an expression ex
as if it had been evaluated.
For methods with n
optional arguments the method returns all those n
methods
defined by the expression ex
. findmethods
handles type parameters in inner
constructors correctly if they have already been pushed into the state
's scope
stack.
When no methods are found to match an expression then an error is raised.
Example:
foobar(x, y = 1) = x + y
state = Docile.State(current_module())
Docile.findmethods(state, :(foobar(x, y = 1) = x + y))
source: Docile/src/method-lookup.jl:262
findmodule(ast, modname)
Recursively walk an expression searching for a module with the correct name.
source: Docile/src/builddocs.jl:203
findsource(obj)
Returns the line number and filename of the documented object. This is based on
the LineNumberNode
provided by ->
and is sometimes a few lines out.
source: Docile/src/macros.jl:92
findtuples(state::State, ex::Expr)
Get all methods from a quoted tuple of the form (function, T1, T2, ...)
.
source: Docile/src/method-lookup.jl:304
format(file)
Extract the format of a file based solely of the file's extension.
source: Docile/src/types.jl:43
funccall(ex::Expr)
Extract the Expr(:call, ...)
from the given ex
.
source: Docile/src/method-lookup.jl:60
funcname(state::State, ex::Expr)
Return the Function
object contained in expression ex
.
This method can handle single line function expressions, standard
function ... end
expressions, ones containing type parameters, and will
also extract the Function
object from method calls.
$
interpolated expressions are also handled for cases where the expression is
evaluated in a for-loop containing @eval
.
Example:
f(x) = 2x
state = Docile.State(current_module())
Docile.funcname(state, :(f(x) = 2x))
Docile.funcname(state, :(f(x)))
source: Docile/src/method-lookup.jl:92
getargs(ex::Expr)
Extract quoted argument expressions from a method call expression.
source: Docile/src/method-lookup.jl:69
getdoc(modname)
Return the Metadata object stored in a module.
source: Docile/src/types.jl:161
gettvars(ex::Expr)
Extract quoted type parameters from an expression.
source: Docile/src/method-lookup.jl:66
include!(meta, path)
Method used to override the behavior of include
.
include!
caches the full path of the included file in a module's Metadata
object and then passes path
argument onto Base.include_from_node1
method
as with the usual behavior of Base.include
.
source: Docile/src/Docile.jl:65
includedast(meta)
Extract docstrings from the AST of included files.
source: Docile/src/builddocs.jl:20
isdocblock(block)
Is the given triplet block
a valid documentation block.
source: Docile/src/builddocs.jl:170
issymbol(s::Symbol)
Handle modules and functions as symbols at later stage.
source: Docile/src/macros.jl:33
lateguess(curmod, symb)
What does the symbol symb
represent in the current module curmod
?
source: Docile/src/macros.jl:37
macroname(ex)
Symbol representing a macro call to the specified macro ex
.
source: Docile/src/builddocs.jl:167
name(ex::Expr)
Extract the symbol identifying an expression.
source: Docile/src/macros.jl:46
object_category(ex)
What does the expression ex
represent? Can it be documented? :symbol is used
to resolve functions and modules in the calling module's context -- after @doc
has returned.
source: Docile/src/macros.jl:6
object_ref(cat, meta, state, ex)
Get the object/objects created by an expression in the given module.
source: Docile/src/builddocs.jl:148
parsefile(file)
Read contents of file
and parse it into an expression.
source: Docile/src/builddocs.jl:4
popref!(state::State)
Remove the object from the top of state
's index references stack.
source: Docile/src/method-lookup.jl:45
popscope!(state::State)
Remove the scope from the top of state
's scopes stack.
source: Docile/src/method-lookup.jl:39
postprocess_entry!(cat::Symbol, meta, ent, ex)
Add additional metadata to an entry based on the category of the entry.
source: Docile/src/builddocs.jl:161
processast(meta, state, file, ex::Expr)
Gather valid documentation from a given expression ex
.
source: Docile/src/builddocs.jl:32
processblock(meta, state, file, block)
Collect object and docstring Entry
object from a valid documentation block.
source: Docile/src/builddocs.jl:114
pushmeta!(doc::Metadata, object, entry::Entry{category})
Warn the author about overwritten metadata.
source: Docile/src/types.jl:129
pushref!(state::State, object)
Push an object onto the top of a state
's index references stack.
source: Docile/src/method-lookup.jl:42
pushscope!(state::State, scope::Dict{K, V})
Add a new scope to top of state
's stack of scopes.
source: Docile/src/method-lookup.jl:36
qualifiedname(ex::Expr)
Returns as a tuple the module name as well as the full method name.
source: Docile/src/macros.jl:56
readdocs(file)
Load and apply format based on extension to the given filename
.
source: Docile/src/types.jl:40
register!(modname)
Register a module modname
as 'documented' with Docile.
source: Docile/src/Docile.jl:15
rootast(meta)
Extract docstrings from the AST found in the root file of a module.
source: Docile/src/builddocs.jl:10
separate(expr)
Split the expressions passed to @doc
into data and object. The docstring and
metadata dict in the first tuple are the data, while the second returned value
is the actual piece of code being documented.
source: Docile/src/macros.jl:70
setmeta!(modname, object, category, source, args...)
Metatdata interface for single objects. args
is the docstring and metadata dict.
source: Docile/src/types.jl:138
setmeta!(modname, objects::Set{T}, category, source, args...)
For varargs method definitions since they generate multiple method objects. Use the same Entry object for each object's documentation.
source: Docile/src/types.jl:152
unravel(entries, meta, state, file, ex::Expr)
Execute for-loops containing @eval
blocks and retrieve documented objects.
When an Expr(:for, ...)
is encountered do the following:
- Walk inner expressions to find
@eval
blocks. Return if none found. - For each multi argument loop expand it into nested loops.
- Execute the outer most loop's variable and loop over the value returned.
- For each loop iteration push new scope onto
state
containing value of loop variable. - Recursively expand the inner loop expressions with this new scope and execute it.
- Pop the current loop iteration's scope after loop has been completed.
source: Docile/src/method-lookup.jl:344
Docs{format}
Lazy-loading documentation object. Initially the raw documentation string is
stored in data
while obj
field remains undefined. The parsed documentation
AST/object/etc. is cached in obj
on first request for it. format
is a
symbol.
source: Docile/src/types.jl:16
Entry{category}
Type representing a docstring and associated metadata in the
module's Documentation
object.
The Docile.Interface
module (documentation available
here) provides methods for working with Entry
objects.
source: Docile/src/types.jl:55
Metadata
Container type used to store a module's metadata collected by Docile.
Each module documented using Docile contains an instance of this object created
using the @document
macro.
Fields:
modname
: The module where this object is defined.entries
: Dictionary containingobject => Entry
pairs.root
: The full directory path to a module's location.files
: Set of all filesinclude
d in a module.data
: Additional metadata collected during module parsing.loaded
: Has the module been parsed and metadata collected?
source: Docile/src/Docile.jl:32
State
The State
type holds the data for evaluating expressions using exec
.
Fields:
mod
: The module object where expressions will be evaluated.scopes
: Stack of local variables defined by for-loops and type parameters.refs
: Stack of objects being indexed into to handleend
and:
uses.
Example:
state = Docile.State(Main)
state = Docile.State(Main, [[:T => TypeVar(:T, Any)]])
source: Docile/src/method-lookup.jl:26


--- layout: post title: Blogging, cameraphones and the mass market date: 2005-01-04 00:00:00 categories: mobile social ---
Sorry to bang on about it, but is Flickr+cameraphone a better blogging tool than most blogging tools?
I've noticed recently that my friends can get a much better view of what I'm up on a day-to-day to by watching my Flickr feed than by reading my weblog (which, let's face it, is quite dull if you're not into the same stuff I am). It's just much easier to me to pop photos up than it is to write a story - pictures being worth a thousand words and all that.
Plus, people who don't know or care about blogs get it.
So, here's my bet: as this stuff gets more popular, blogging tools that are focused around easily getting video and imagery out of our phones and into the eyes of our friends will be where the mass market turn... leaving essayists with the more texty tools that we know and love today.


Use onCountryPicked() API to set callback function when a new country is clicked
View Source
Get country name from callback


About UFID
Community
Source
Release Candidate 1.4
(Subject to change)
Physical size
Nominal Diameter (mm):
Tolerance (ħmm):
Full Spool volume (cm 3 ):
Thermal Profile
Recommended Print Temp. (C):
Do Not Exceed Temp(C):
Print Bed Temp.  Would you like to submit the hexadecimal information you have compiled? Please note that submitting your hex will clear the page.
Submit hex


#JL777 summarizing how a crypto-backed stablecoin will work within the $KMD ecosystem! Innovating constantly!
Platform-wide update to add such features will commence on December 20, 2019 at block height 1,670,000 for those curious!
@notsofast thoughts?


|
|||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object org.apache.commons.discovery.resource.ClassLoaders
There are many different contexts in which loaders can be used. This provides a holder for a set of class loaders, so that they don't have to be build back up everytime...
| Field Summary | |
protected java.util.Vector |
classLoaders
|
| Constructor Summary | |
ClassLoaders()
Construct a new class loader set |
| Method Summary | |
java.lang.ClassLoader |
get(int idx)
|
static ClassLoaders |
getAppLoaders(java.lang.Class spi,
java.lang.Class factory,
boolean prune)
Utility method. |
static ClassLoaders |
getLibLoaders(java.lang.Class spi,
java.lang.Class factory,
boolean prune)
Utility method. |
boolean |
isAncestor(java.lang.ClassLoader classLoader)
Check to see if classLoader is an
ancestor of any contained class loader. |
void |
put(java.lang.ClassLoader classLoader)
Specify a new class loader to be used in searching. |
void |
put(java.lang.ClassLoader classLoader,
boolean prune)
Specify a new class loader to be used in searching. |
int |
size()
|
| Methods inherited from class java.lang.Object |
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Field Detail |
protected java.util.Vector classLoaders
| Constructor Detail |
public ClassLoaders()
| Method Detail |
public int size()
public java.lang.ClassLoader get(int idx)
public void put(java.lang.ClassLoader classLoader)
public void put(java.lang.ClassLoader classLoader, boolean prune)
prune
- if true, verify that the class loader is
not an Ancestor (@see isAncestor) before
adding it to our list.public boolean isAncestor(java.lang.ClassLoader classLoader)
classLoader
is an
ancestor of any contained class loader.
This can be used to eliminate redundant class loaders
IF all class loaders defer to parent class loaders
before resolving a class.
It may be that this is not always true. Therefore,
this check is not done internally to eliminate
redundant class loaders, but left to the discretion
of the user.
public static ClassLoaders getLibLoaders(java.lang.Class spi, java.lang.Class factory, boolean prune)
spi
- WHAT is being looked for (an implementation of this class,
a default property file related to this class).factory
- WHO is performing the lookup.prune
- Determines if ancestors are allowed to be loaded or not.public static ClassLoaders getAppLoaders(java.lang.Class spi, java.lang.Class factory, boolean prune)
spi
- WHAT is being looked for (an implementation of this class,
a default property file related to this class).factory
- WHO is performing the lookup (factory).prune
- Determines if ancestors are allowed to be loaded or not.
|
|||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


2020-2023
--
2020
> Database Systems (DBMS)
> Relational Algebra
> Computer Architecture
> Fundamental Data Structure and Algorithm
> Technical Writing
> English for Engineering
2018-2019


Consider the given recurrence:
Now, user have to determine the asymptotic upper bound on this given relation using a recurrence tree. It is already known that, the floor and ceil value usually do not matter in solving recurrences.
Consider the following recurrence tree for the given recurrence. Here, the value of is assumed exact power of 2 for convenience. It is chosen as exact power of 2 because all the sub-problems sizes became integer.
In the above recurrence tree,
• At each time when user go down one level, the subproblems sizes decreases by a factor 2, user eventually must reach a boundary condition .
• To calculate the depth of the tree, user obtain the sub-problem size for a node at depth i is .
• Therefore, the sub-problem size hits when or, .
Hence, the tree has levels.
Now, user have to determine the cost at each level of the tree. At each level, the nodes increased 3 times as the node exists on the above level. So the number of nodes at depth is given as.
It has already known that, “at each time when user go down one level, the subproblems sizes decreases by a factor 2”, so each node at depth , where , has a cost of .
Now, the total cost over all nodes at depth , will be obtain after taking the product of the number of nodes at depth and the cost of each node at the depth .
Therefore,
At the bottom level where the depth is equal to, the number of nodes will be given as, where the contribution of the cost by each node is.
Therefore, the total contribution of the cost at bottom level is, which is Here, it is assumed that the value of is constant.
Now, user have to sum up the costs over each levels to determine the cost for the entire tree:
Now, use the Sigma to add all the elements except the last one.
Now, use the geometric series formula, then user will obtain:
Now, evaluate the fraction,
Hence, the asymptotic upper bound on this given recurrence is given by.
A recursion tree to determine a good asymptotic upper bound on the recurrence
The costs over all levels to determine the cost for the entire tree:
Now, we can use the substitution method to verify that our guess was correct, that is is an upper bound for the recurrence .We want to show that for some constant.
This condition holds when n>0 and d=4.
Hence, asymptotic of the upper bound on the recurrence is verified.
• The recursion tree is used to calculate the time taken by any recursive algorithm for its recurrence relations.
• Recursion tree is the parse tree generated by using the recurrence relation.
• In the recursion tree method we first generate the tree for the given recurrence relation and then calculate the complexity for the base case that is and then from this user calculate the complexity for the n.
The general recurrence relation where is the number of sub-problems and is the size of each sub problem:
…… (1)
Now consider the recurrence relation provided in the question.
…… (2)
The recursion tree for the recurrence relation in the equation (2) is as follows:
Here the tree is derived from the constant function n and divides into 4 sub-problems each having size of.
• For the simplification of the problem, ignore the constant term, that is, 2 in. The tree extends to its trivial case.
• The sub-problem size of node at depth i is n/2i .Thus, the sub-problem size hits n=1 when n/2i =1.
Length of the tree will be given as
or …… (3)
Taking the log of equation (3)
So,
(Since log 2 =1)
Each level has 4 times more nodes than the previous above. So, the number of leaves at level i are 4i.
Now, put the value of i, then the number of leaves at level i will be given as:
Simplifying further,
Since at i = log n, T(n/2i) = T(1) , so each leaf in contributing cost T(1). Total cost is n2 since it is assumed that T(1) is constant.
Now the equation can be written as:
Taking out constant n, user can solve this expression by taking only the first value of i which is 0 because c(1/2i) is a decreasing geometric progression.
Now, ignoring the decreasing constants
…… (4)
Since for upper bound, user can take the max of (n, n2). Hence, equation (4) shows a good asymptotic upper bound for the recurrence relation.
Now use substitution method to verify the solution of recurrence relation.
The upper bond of of the problem should be less than or equals to the terms at the right hand side with as the outer boundary
So,
Hence recurrence tree method and the substitution method builds up a complexity of
Recursion tree is a tree generated by calling the problem recursively. Each node in the rcursion tree reprsents the cost or time taken by a single sub problem. Recursion tree is used to find a good upper bound on a recurrsion. The total cost of the whole problem can be obatained by adding costs of all sub problems.
Finding upper bound on the using recursion tree:
The given recurence is …...(1)
Generate the recursion tree by calling T(n) recursively as follows:
Further calling the problem recursively, the following fully expanded tree is obtained.
Now the total cost =
=
=
Therefore the is the uppder bound on the given reucrrence .
The above upper bound can be verified using the substitution method as follows:
In the substitution method a solution is gussed every time and checked wether it is working or not.
Assume that is the solution for the given recurrence.
Thus, it is requried to show . Where the constant
Now substitute the result of the guess in the given recurrence.
Now make a furtehr smaller guess, that is , where the constant .
Thus,
The abvoe condition is true for .
Therefore it is verified that is the uppder bound on the given reucrrence .
Recursion tree for the recurrence relation is:
Total: O(nlogn)
The longest simple path from the root to a leaf is since, when ,the height of the tree is ,the height of the part of the tree in which every node has two children is log3 n.
The cost at each level of the tree is exactly c*n. To find a lower bound on the cost of the algorithm, a lower bound is required on the height of the tree.
Since the values at each of these levels of the tree add up to cn, the recurrence relation is at least
The given recurrence is, .
The recursion tree for given recurrence is,
The cost at each level is the code of the node. There are levels in the tree. When the cost at each level is summed, the total cost of the algorithm is:
Now assume that n is divisible by a and ignore the ceiling functions, so the asymptotic complexity becomes:
The given recurrence is .
Let so that.
The recursion tree for given recurrence is,
The recursion tree is full for, each contributing cn. Therefore let the guess be .
It has levels, each contributing. Therefore, the guess is,.
Show by substitution method as follows:
To get the upper bound, show that d > 0.
.
This is same as.
As .
Thus, , so that when multiplied, both sides of the inequality by this factor, the inequality is to be reversed.
The fraction on the right – hand side is a positive constant, and so it suffices to pick any value of d that is greater than or equal to this fraction.
To prove lower bound, show that T (n) for some d>0.
The same proof as for the upper bound can be used by substituting.
Thus, .
Therefore, .


HOLA to the geeks, come and communicate and interact with the coding and tech community of SRMS CET&R. We are happy to have you.
For people who are ready to get involved in technical as well as non-technical discussions. Feel free to contact anytime!
Contact :From here you can meet and greet people like you and can interchange ideas. It is a place for learning and growing together.


Recent graduate with specialty in multisensory, goal-oriented programming solutions through software engineering and team planning. Eager learner and problem-solver with 1+ years of education experience with SQL Server, HTML, JavaScript, CSS, and agile.
Bachelor of Science in Computer Science , 3.8 GPA, Lakeland University 2019 - 2021
AAS Electrical Engineering Technology, Fox Valley Technical College, 2015 - 2017
| Novice | Competent | Expert |
|---|---|---|
| Python | SQL | Solidworks |
| Json | JavaScript | Microsoft |
| HTML | ||
| CSS | ||
| Java8 | ||
| C#/C++ |


Sampling procedures from the book 'Stichproben - Methoden und praktische Umsetzung mit R' by Goeran Kauermann and Helmut Kuechenhoff (2010).
| Version: | 1.2.2 |
| Depends: | pps, sampling, survey |
| Published: | 2017-05-23 |
| Author: | Juliane Manitz, contributions by Mark Hempelmann, Goeran Kauermann, Helmut Kuechenhoff, Shuai Shao, Cornelia Oberhauser, Nina Westerheide, Manuel Wiesenfarth |
| Maintainer: | Juliane Manitz <r at manitz.org> |
| License: | GPL-2 | GPL-3 [expanded from: GPL (≥ 2)] |
| NeedsCompilation: | no |
| In views: | OfficialStatistics |
| CRAN checks: | samplingbook results |
| Reference manual: | samplingbook.pdf |
| Package source: | samplingbook_1.2.2.tar.gz |
| Windows binaries: | r-devel: samplingbook_1.2.2.zip, r-release: samplingbook_1.2.2.zip, r-oldrel: samplingbook_1.2.2.zip |
| OS X binaries: | r-release: samplingbook_1.2.2.tgz, r-oldrel: samplingbook_1.2.2.tgz |
| Old sources: | samplingbook archive |
| Reverse suggests: | PracTools |
Please use the canonical form https://CRAN.R-project.org/package=samplingbook to link to this page.


#include <bmqt_sessionoptions.h>
List of all members.
Detailed Description
value-semantic type for options to configure a session with a BlazingMQ broker
See Component bmqt_sessionoptions
Constructor & Destructor Documentation
| bmqt::SessionOptions::SessionOptions |
( |
bslma::Allocator * |
allocator = 0 |
) |
[explicit] |
| bmqt::SessionOptions::SessionOptions |
( |
const SessionOptions & |
other, |
|
|
bslma::Allocator * |
allocator = 0 | |
|
) |
| | |
Create a new SessionOptions by copying values from the specified other
, using the optionally specified allocator
.
Member Function Documentation
| SessionOptions& bmqt::SessionOptions::setBrokerUri |
( |
const bslstl::StringRef & |
value |
) |
|
Set the broker URI to the specified value
.
| SessionOptions& bmqt::SessionOptions::setProcessNameOverride |
( |
const bslstl::StringRef & |
value |
) |
|
Set an override of the proces name to the specified value
.
| SessionOptions& bmqt::SessionOptions::setNumProcessingThreads |
( |
int |
value |
) |
|
Set the number of processing threads to the specified value
.
Set the specified value
for the size of blobs buffers.
| SessionOptions& bmqt::SessionOptions::setChannelHighWatermark |
( |
bsls::Types::Int64 |
value |
) |
|
Set the specified value
(in bytes) for the channel high watermark. The behavior is undefined unless 8 * 1024 * 1024 < value
.
| SessionOptions& bmqt::SessionOptions::setStatsDumpInterval |
( |
const bsls::TimeInterval & |
value |
) |
|
Set the statsDumpInterval to the specified value
. The behavior is undefined unless value
is a multiple of 30s and less than 60 minutes.
| SessionOptions& bmqt::SessionOptions::setConnectTimeout |
( |
const bsls::TimeInterval & |
value |
) |
|
| SessionOptions& bmqt::SessionOptions::setDisconnectTimeout |
( |
const bsls::TimeInterval & |
value |
) |
|
| SessionOptions& bmqt::SessionOptions::setOpenQueueTimeout |
( |
const bsls::TimeInterval & |
value |
) |
|
| SessionOptions& bmqt::SessionOptions::setConfigureQueueTimeout |
( |
const bsls::TimeInterval & |
value |
) |
|
| SessionOptions& bmqt::SessionOptions::setCloseQueueTimeout |
( |
const bsls::TimeInterval & |
value |
) |
|
Set the timeout for operations of the corresponding type to the specified value
.
Set a HostHealthMonitor
object that will notify the session when the health of the host has changed.
Set the DTContext
and DTTracer
objects needed to integrate with Distributed Trace frameworks. Either both arguments must point to valid instances, or both must be empty shared_ptr's; if either is an empty shared_ptr and the other is not, then behavior is undefined.
| SessionOptions& bmqt::SessionOptions::configureEventQueue |
( |
int |
queueSize, |
|
|
int |
lowWatermark, |
|
|
int |
highWatermark | |
|
) |
| | |
DEPRECATED: Use 'configureEventQueue(int lowWatermark, int highWatermark)' instead. This method will be marked as BSLS_ANNOTATION_DEPRECATED
in future release of libbmq.
| SessionOptions& bmqt::SessionOptions::configureEventQueue |
( |
int |
lowWatermark, |
|
|
int |
highWatermark | |
|
) |
| | |
Configure the EventQueue notification watermarks thresholds with the specified lowWatermark
and highWatermark
value. Refer to the component level documentation for explanation of those watermarks. The behavior is undefined unless lowWatermark < highWatermark
.
| const bsl::string& bmqt::SessionOptions::brokerUri |
( |
|
) |
const |
| const bsl::string& bmqt::SessionOptions::processNameOverride |
( |
|
) |
const |
Return the process name override.
| int bmqt::SessionOptions::numProcessingThreads |
( |
|
) |
const |
Get the number of processing threads.
| int bmqt::SessionOptions::blobBufferSize |
( |
|
) |
const |
Get the size of the blobs buffer.
| bsls::Types::Int64 bmqt::SessionOptions::channelHighWatermark |
( |
|
) |
const |
Get the channel high watermark.
| const bsls::TimeInterval& bmqt::SessionOptions::statsDumpInterval |
( |
|
) |
const |
Get the stats dump interval.
| const bsls::TimeInterval& bmqt::SessionOptions::connectTimeout |
( |
|
) |
const |
| const bsls::TimeInterval& bmqt::SessionOptions::disconnectTimeout |
( |
|
) |
const |
| const bsls::TimeInterval& bmqt::SessionOptions::openQueueTimeout |
( |
|
) |
const |
| const bsls::TimeInterval& bmqt::SessionOptions::configureQueueTimeout |
( |
|
) |
const |
| const bsls::TimeInterval& bmqt::SessionOptions::closeQueueTimeout |
( |
|
) |
const |
Get the timeout for the operations of the corresponding type.
| const bsl::shared_ptr<bmqpi::DTContext>& bmqt::SessionOptions::traceContext |
( |
|
) |
const |
Get the Distributed Trace context object.
| const bsl::shared_ptr<bmqpi::DTTracer>& bmqt::SessionOptions::tracer |
( |
|
) |
const |
Get the Distributed Trace tracer object.
| int bmqt::SessionOptions::eventQueueLowWatermark |
( |
|
) |
const |
| int bmqt::SessionOptions::eventQueueHighWatermark |
( |
|
) |
const |
| int bmqt::SessionOptions::eventQueueSize |
( |
|
) |
const |
DEPRECATED: This parameter is no longer relevant and will be removed in future release of libbmq.
| bsl::ostream& bmqt::SessionOptions::print |
( |
bsl::ostream & |
stream, |
|
|
int |
level = 0 , |
|
|
int |
spacesPerLevel = 4 | |
|
) |
| | const |
Format this object to the specified output stream
at the (absolute value of) the optionally specified indentation level
and return a reference to stream
. If level
is specified, optionally specify spacesPerLevel
, the number of spaces per indentation level for this and all of its nested objects. If level
is negative, suppress indentation of the first line. If spacesPerLevel
is negative format the entire output on one line, suppressing all but the initial indentation (as governed by level
). If stream
is not valid on entry, this operation has no effect.
Member Data Documentation
Initial value:
5 * bdlt::TimeUnitRatio::k_SECONDS_PER_MINUTE
The documentation for this class was generated from the following file:


--- layout: archive title: Zulip Chat Archive permalink: /stream/113489-new-members/topic/natural.20number.20game.20questions.html ---
hi all! absolutely loving the natural number game (kudos @Kevin Buzzard). i had a few (largely silly) questions.
for adv proposition world, level 9, is there a way to beat it with only the tactics we know so far other than cc
or tauto
? in the second case, i spent a few minutes trying to figure out how to capitalize on having P \land \lnot P
in hand before googling and discovering the contradiction
tactic. was i missing a more "bare-handed" approach?
for adv proposition world, level 8, there's a "did you spot the import" comment at the end that's mysterious to me ... what import?
is there a github repo where the code for the game lives?
... and a followup: how does one get inline expansion for latex here? ;)
3 -> https://github.com/ImperialCollegeLondon/natural_number_game
by_cases hq : Q,
and exfalso
(I guess that shows up in the next level though...) (edit: and you can replace exfalso
by either using the term false.elim
or by using cases H
on a hypothesis H : false
.)import tactic.finish
in the source Lean file here and that paragraph was a subtle hint for you to try the finish
tactic. Unfortunately, the import isn't visible in the generated HTML...awesome, thanks!
Inspired by @Scott Morrison I returned to the natural numbers game this weekend and was delighted to see all the new tactics and new levels. I feel like I'm getting somewhere now. Thanks everyone.
Now here's my question: I'm stuck on mul_left_cancel in the advanced multiplication world. I'd like to prove (a !=0) -> (a b = a c) -> b = c by (strong) double induction on b and c. This should give me four cases, three of which involve the hypothesis that either b or c is zero. Then for the fourth the plan is to use add_left_cancel to conclude from the hypothesis
a (succ b) = a (succ c)
that
a b = a c.
Then the inductive hypothesis should give me b = c, whence succ b = succ c.
But I have no idea how to set up this double induction. The hint says to use revert but I don't see where it would help.
My guess is that you want a forall
in the goal at the moment you invoke induction
, and to achieve that you need to use revert
.
Spoiler:
revert c, induction b, { intro c, sorry, }, { intro c, induction c, { sorry, }, { sorry, } }
(I haven't actually tried doing the proof after that step, I'm just guessing that's the structure you wanted.)
Thanks @Scott Morrison . That did the trick.
Here's the full gory thing (spoiler below):
revert c,
induction b with x hx,
intro c,
rw mul_zero,
intro hyp,
symmetry at hyp,
have lem := eq_zero_or_eq_zero_of_mul_eq_zero _ _ hyp,
cases lem with p q,
exfalso,
exact ha p,
symmetry,
assumption,
intro c,
induction c with y hy,
intro hyp,
rw mul_zero at hyp,
have lem := eq_zero_or_eq_zero_of_mul_eq_zero _ _ hyp,
cases lem with p q,
exfalso,
exact ha p,
assumption,
intro hyp,
repeat {rw mul_succ at hyp},
have lem := add_right_cancel _ _ _ hyp,
have step := hx y lem,
apply succ_eq_succ_of_eq,
assumption,
Next you need some braces and indenting. :-)
Haha on point ;)
Ah, earlier I couldn't work out why ex_falso
didn't exist... Apparently because it's exfalso
, but by_contradiction
.
@Kevin Buzzard, what do you think of adding a @[simp] lemma that says succ n = n + 1
? In some of the later levels I find myself writing proofs that want to use this fact often.
@Emily Riehl Congrats!
This is a bad level. Without revert it's probably impossible and I do a really bad job of explaining how revert works. This needs to be fixed
It can be done without revert if you use induction b generalizing c
instead (which is the correct way to do inductions like this anyway)
It's debatable, but I think it is a good teaching moment to explain what it means to generalize an argument in an induction. This came up in discussions at the meeting in bonn
I will get back to this game in a few weeks and update it. There are several minor changes I want to make
apologies if I am being useless; on question 8 of advanced addition world, and whenever I try to use succ_inj something goes wrong.
b n : mynat,
an : n + b = n → b = 0,
h : succ (n + b) = succ n
⊢ b = 0
I want to apply succ_inj to h by applying it to h with parameters n+b and b, but this always raises an error. When I've had problems like this on previious levels, I've used the 'have' tactic, but this also won't import because it seems to get confused by the parameter name n+b
does have h2 := succ_inj h
work?
I guess you could just go backwards the way the computer scientists want you to do -- apply an
and then apply succ_inj
will presumably work.
It looks like the official solution
ah thank you that works ! i also hadnt realised there was an official solution set oops so thank you for that also
also really enjoying the game, so thanks for making it :)
I'm not sure it's officially documented anywhere that there's an official solution set :-)
when calling a function, such as succ_inj or mul_pos, how do you pass in arguments which themselves are functions?
For instance,
have f := mul_pos a b,
works but
have f := mul_pos succ(a) succ(b),
does not work, with the error message indicating that it expected something of type mynat, whereas it read s succ as a function from mynat to mynat.
thank you:)
You probably need to wrap succ(a)
and succ(b)
itself in parentheses, like so: have f := mul_pos (succ(a)) (succ(b))
The parentheses around a
and b
in succ(a)
and succ(b)
are unnecessary. Note that you can also take advantage of "dot notation" and write have f := mul_pos a.succ b.succ
.
thank you both:)
You're welcome :smile:
I always put the parentheses in succ(a)
in the natural number game because I felt it was less intimidating for mathematicians
yes I find that much more natural
However this shows a downside to this idea -- succ(a)
looks like an irreducible gadget to a mathematician, but is apparently parsed as succ a
and hence succ
can fall off and be eaten by an earlier function.
@Ethan Horsfall FYI the notation for function application in (functional) programming differs from that in conventional mathematics, for example f(x)
in mathematics could be simply written as f x
in Lean
on the last level of advanced multiplication world, i have got it to the point where I have the hypothesis
c : mynat,
c_ih : ∀ (a : mynat), a ≠ 0 → ∀ (b : mynat), a * b = a * c → b = c, ###
a : mynat,
ha : a ≠ 0, ###
n : mynat,
g : a * n + a = a * c + a,
W : a * n + a = a * c + a → a * n = a * c
⊢ a * n = a * c → n = c ###
I have put ### by the remaining relevant propositions
which should be very simple as if we only look at c_ih and ha, the goal is just a restatement of this. but i cannot work out how to introduce the right variables into c_ih or revert the goal correctly. The propositions in the middle muddle it up when I use revert
Does exact c_ih a ha n
work?
You can think of c_ih
as a function, which takes as input a natural number a
, a proof that it's not zero, and a natural number b
, and returns a proof that ab=ac -> b=c
.
Also you should be able to apply c_ih
and let Lean work out what additional arguments are needed.
(either supplying them automatically or turning them into new goals)
thank you, that seems to have worked. the slightly weird thing is that it now just says 'no goals' instead of proof complete. viewing it as a function makes a lot of sense
?? I'm impressed :-) I thought Mohammad had managed to completely banish "no goals"!
Finished the game!!
is the official documentation the best place to go next?
Ethan Horsfall said:
is the official documentation the best place to go next?
That, or you could try Theorem Proving in Lean next which teaches you how to define your own functions, mathematical objects, etc. on top of proving theorems with tactics.
In addition to TPiL, I found the Logic & Proof book useful when I was learning Lean. I also like the Logical Verification notes.
If you're a mathematician then one thing you could try is to choose an arbitrary piece of elementary mathematics and try doing it in Lean, and ask when you get stuck. For me the route was: basic 1st year introduction to proof stuff, definition of a scheme, theorems about schemes, definition of a perfectoid space. Because there is no ideal book for mathematicians we have to forge our own path right now. I guess there are always the maths challenges if they're up your street. What are you looking for?
PS @Ethan Horsfall Mohammad says that if you can reproduce "no goals" then you should tell us how and he'll try and fix it ;-) He's just submitted his PhD thesis so I'm sure he has plenty of time on his hands :-)
I'm an undergraduate student. (actually, an undergraduate economist, but I just secured my switch to maths recently :) ). I'm in the fortunate position of mostly pursuing what I find interesting. for the 'no goals' every time I refreshed the page it would lose previous progress, so I may not be able to reproduce it
What maths do you know already?
i've covered https://dec41.user.srcf.net/notes/ all of part ia except dynamics and relativity, and ib linear algebra, markov chains, and partway through some others
Are you in Cambridge right now? You know they have a Lean meeting on Wednesday evenings?
If you want to help make the group theory game, the current state of it is here
I am in cambridge right now, and didn't know there was a lean meeting! i doubt i have enough experience to be much help but would be willing to try :)
Believe me, I'm sure you'll be welcome. @Edward Ayers is perhaps the person to talk to about it. Bring some friends ;-)
I'm at an Imperial meeting right now.
Hi @Ethan Horsfall I've added you to the secret Cambridge group. meetings are 15:00 to 18:00 on Wednesdays somewhere in the CMS room TBC. The meeting is for all skill levels, there are 3 or 4 people learning the natural numbers game. If anyone else wants to be added to the cambridge group then ask me. I think if you are a member of the group you can add new members?
Level 8 of the Advanced Proposition World says
Pro tip
Did you spot the import? What do you think it does?
I do not see any import though. What am I missing? Was it a mathlib import?
Let's look in the source code :-)
Does finish
just finish the level in one move?
This looks like an outdated comment -- it is impossible to spot the import if you're playing the game because of the --hide
Looks like there was a commit where I hid the import, but didn't change the comment.
Cool. Thanks!
@Kevin Buzzard , I noticed that the statement of pow_succ in the sidebar is wrong. it says that pow_succ (a b : mynat) :
a ^ succ(b) = a ^ b * b
, but I think it should be a^b*a
Yeah I know, it's on the list of things to fix. Thanks.
How would one go writing a tactic that will select the first assumption in context that can be apply
ed to the goal?
and apply it
The spoilery way is to look at the implementation of the assumption
tactic in core Lean:
meta def assumption : tactic unit := do { ctx ← local_context, t ← target, H ← find_same_type t ctx, exact H } <|> fail "assumption tactic failed"
Here, local_context
gets the list of hypotheses, and target
gives the goal type.
So instead of find_same_type
, which finds the hypothesis with the exact same type as the goal, we could iterate over the local_context
and try to apply
each element in turn until it succeeds.
Thanks. It somehow didn't occur to me to look at the definition of the basic tactics.
The best introduction we have to learning to write tactics in Lean is programming in Lean, which is a bit out of date but which does contain lots of juicy information. After that people just tend to ask in the chat.
The best introduction we have to learning to write tactics in Lean is programming in Lean,
I think the Logical Verification notes are also a good source (certainly less out of date).
We're working on a 2nd edition. Keep an eye on the same URL, but with 2020 instead of 2019.
Recall we also have documentation in mathlib.
Do we know why sometimes we get stuck with "Lean is busy" in the natural numbers game?
It's happened to us again.
@Kevin Buzzard, I was just looking at the natural numbers game repo, and wondering about some a few things.
Are the src/my_solutions/
and src/solutions/
directories obsolete?
(The README currently suggests that if you wan to play the game in VSCode to use those directories, but they seem quite out of date relative to the src/game/
directory.)
It would be fun to be able to hack on this.
Yes I can quite believe that those directories are obsolete. I have no idea about any of the web issues. @Mohammad Pedramfar ?
Yes, the game maker only looks at the lean files specified in the game_config.toml file, which in this case are all contained in the game folder. The only other things that are needed are the files that are imported which, in this case, are contained in the mynat and tactic folder. The rest aren't needed.
Had a lot of fun with natural number game! Looking forward to more games.
The web game format works amazing. No setup hassle required at all.
Is real-number-game
available on the web?
no, there is no real number game. Someone was coming to visit me in May and work on it but unfortunately this is now all up in the air. I should try and get a fan club together.
Inequality world Level 6
cases hab, cases hba, rw hab_h at hba_h, rw add_assoc at hba_h, symmetry at hba_h, have h00: (hab_w + hba_w) = 0 := eq_zero_of_add_right_eq_self _ _ hba_h, cases hab_w, { rw hab_h, refl, -- cursor here shows 'no goals' }, { }
@Mohammad Pedramfar
Since the game does not introduces { ... }
, I guess it is not an issue.
No goals is correct with the cursor there because you have finished the goal which you isolated
Oh -- but the point is that it doesn't say "proof complete" or whatever?
Yeah, guess "no goals" is okay
Concerning the logical verification notes discussed on March 9, be aware that there's a new version now, available under "material" below:
https://lean-forward.github.io/logical-verification/2020/index.html#material
It's much better than the old book. Please tell anybody who's reading the old one to stop! ;)
{% endraw %}Last updated: Apr 24 2020 at 19:02 UTC


Preparing Runtime... Downloading MATLAB Runtime installer from "https://www.mathworks.com/supportfiles/downloads/R2018a/deployment_files/R2018a/installers/glnxa64/MCR_R2018a_glnxa64_installer.zip". Downloading MATLAB Runtime installer was cancelled.


A channel to discuss trading. For useful links and more info click the pinned messages to the right.
100 messages
Before 05-Dec-19 12:00 AM
grewalsatinder09-Oct-18 10:43 AM
yep
from day one.
ComputerGenie 👴👴👴09-Oct-18 10:43 AM
in short:
“I have a fifty dollar note here ... willing to swap with ten dollar note yuan” works
“I have 2 twentys and a ten ... willing to swap with ten dollar note yuan” does not
house09-Oct-18 10:44 AM
understood
jl777c09-Oct-18 10:44 AM
so really how hard is this to understand?
people seem to spend more time saying they dont understand it, than the 5 minutes it would take to learn it
house09-Oct-18 10:44 AM
Is not now
jl777c09-Oct-18 10:44 AM
not sure why
and then blame the atomic swaps for being hard to understand
ComputerGenie 👴👴👴09-Oct-18 10:45 AM
It's not that it's hard; imo, most just never take the time to try to understand and just keep trying to apply what they are used to knowing
house09-Oct-18 10:45 AM
Habit
jl777c09-Oct-18 10:46 AM
so where is my 0 calorie ice cream?
ComputerGenie 👴👴👴09-Oct-18 10:46 AM
also why a GUI is so dam'd hard to make
Well Bittrex doesn't work like that
house09-Oct-18 10:47 AM
There are many ‘creams’ I could freeze and blend, not sure they would be tasty tho
ComputerGenie 👴👴👴09-Oct-18 10:47 AM
tmi
jl777c09-Oct-18 10:47 AM
sorry, not willing to spend any effort and it must be just as good
house09-Oct-18 10:47 AM
You buy them already that way
Processed
jl777c09-Oct-18 10:48 AM
I want the benefit of 0 calories, but not willing to spend any extra effort at all, and will complain until it tastes just as good
it needs to be free too
it doesnt have any calories, so it should be free
until you make such an ice cream it wont go mainstream
house09-Oct-18 10:49 AM
Hehe, ok you are pushing your point hard, I understand much better now
ComputerGenie 👴👴👴09-Oct-18 10:49 AM
and will complain until it tastes just as good
For the 1st few months I was there, I'd bet that there were people in #dev-tradebots that swore that was me
jl777c09-Oct-18 10:50 AM
to gain the benefit of atomic swaps, you need to spend at least 5 minutes understanding the basics
if not, then use token based systems
(processed food equivalent)
ComputerGenie 👴👴👴09-Oct-18 10:51 AM
was going to go take a nap like 4 hrs ago
snowdamn09-Oct-18 10:52 AM
all i care about UTXO is that it allows smart contract CCs to scale along with tx scaling
ComputerGenie 👴👴👴09-Oct-18 10:53 AM
all i care about UTXOs is that I don't have enough of them over 10KMD
jl777c09-Oct-18 10:54 AM
utxo makes the CC much safer, no chance of issuing gazillions of coins due to contract error
in a balance based system, if some contract bug (that all nodes agree to) has some sort of overflow error (yes has happened), then the coin supply changes
with utxo system, only specific utxo are at risk
2
1
2
ComputerGenie 👴👴👴09-Oct-18 10:56 AM
limiting risk and adding chain security? who wants that?
2
jl777c09-Oct-18 10:57 AM
utxo based systems have a chain going back to the coinbase they were mined in
balance based systems act a bit like a mixer and it becomes a bit probabilistic the history of any specific coins
ComputerGenie 👴👴👴09-Oct-18 10:59 AM
every reason I'm so invested in PIRATE, with all t txes all it takes is enough computing power and you can track pretty much every satoshi
now, if you'd just make me an exchange to trade it on, that'd be nice
1
snowdamn09-Oct-18 11:01 AM
yes, tortuga will do the whole project justice IMO
ComputerGenie 👴👴👴09-Oct-18 11:04 AM
trying to arbitrage OTC for 0.01-0.03 KMD per is getting tedious
The biggest upgrade of any public blockchain since their invention has now reached the stage of a “software development slog,” according to Vitalik Buterin, Chief Scientist at the Ethereum Foundation....
"The biggest upgrade of any public blockchain since their invention has now reached the stage of a “software development slog,” according to Vitalik Buterin, Chief Scientist at the Ethereum Foundation."
That reminds me of the Trolls movie
"The biggest, loudest, craziest best party ever"(edited)
Until crypto media get over the trolls party complex, we are doomed.(edited)
Hollowman900009-Oct-18 01:16 PM
So how do you think the 51% attack will go on einsteinium
Oct 13 0400 EST
ComputerGenie 👴👴👴09-Oct-18 01:17 PM
I think that it will non-impressively happen and not really prove much of anything.
Hollowman900009-Oct-18 01:18 PM
They’re dPoW
jl777c09-Oct-18 01:19 PM
not quite
not all nodes are updated
Hollowman900009-Oct-18 01:19 PM
So they’re forked then
snowdamn09-Oct-18 01:20 PM
jl777c09-Oct-18 01:20 PM
as long as the mining nodes and the exchanges, explorers are updated, only non-updating user nodes would go on a fork and they just need to update. it not like any double spend will be done against a lone end user
ComputerGenie 👴👴👴09-Oct-18 01:22 PM
was not aware of the switch to dPoW
Hollowman900009-Oct-18 01:23 PM
So the scheme would be what, privately mine an offline fork, make a spend on the main net, then bring the private fork online with >51% hashpower?
Kitchen Table09-Oct-18 01:24 PM
Of all the low hashrate coins out there to attack, I find it ironic he chooses one of the few protected by dPoW. If my tinfoil hat wasn't so tight I would put it on and claim a setup to pump KMD.
jl777c09-Oct-18 01:25 PM
we dont want to say it is dPoW yet as it is not fully dPoW
1
Hollowman900009-Oct-18 01:25 PM
Well the malicious miner goes by a handle with “pirate” in it
KomodoWorld09-Oct-18 01:26 PM
I talked with him via pm on Reddit, he definitely doesn't know about dPoW or Komodo. Of course I didn't spoil anything if he doesn't do research...


{border-style px;} #ffffff;} surgical patients Orthopaedic medical COVID- []. px; surgeons {font-family font-size health orthopaedic pandemia trauma coronavirus crisis double; services used (https://www.bloomberg.com/opinion/articles/--/the-coronavirus-crisis-is-putting-surgeons-at-risk-too). Chinese border-color border-width care hospitals information operating published reviewers solid; virus {font-style {font-weight bold cases courier; disease em; group however, infected number patients, pt;} quality reserved review


{{project.contributions}}
{{project.date}}
{{project.description}}
As a result, one new mozillian, Breana Jones , has really taken initiative. Last night she attended an IRC meetup with Mozilla Mexico, she’s added herself to the es-MX team wiki page, and has announced that she will coordinate the l10n efforts for Firefox for Android to ensure that it is launched in the multilocale builds with Firefox 30.


From:Kitchen Louise To:Allen Phillip K. ; Lavorato John Sent:2017-01-11T04:41:58.0000000Z Subject:FW: Enron Management Conference - Home Video Project
Any volunteers to take on this project?
-----Original Message-----
From: James, Terrie
Sent: Tuesday, September 25, 2001 12:35 PM
Subject: Enron Management Conference - Home Video Project
The Enron Management Conference will be held Wednesday through Friday, November 14-16, 2001, at the Westin La Cantera Resort in San Antonio. While the business agenda is still being finalized, there is one thing that is certain ... we want to inject some humor into the event. The past year has been eventful, and at times challenging, for Enron and its employees. However, it's not in Enron's corporate fabric to focus on the past. Instead, we want to look ahead, and even laugh at ourselves. The Management Conference will provide a platform for just that.
We want to challenge each of the business units to develop and submit a humorous "Home Video" to be presented at the Management Conference. The video can address any Enron-related topic that your business unit chooses. However, there are a few rules to follow.
1.) The videos should be no more than five minutes long.
2.) Business units should spend as little as possible on the videos, and no more than $10,000. Innovision Communications (Beth Stier) has agreed to work with any business unit to help them create an original, inexpensive video. Innovision can be contacted at<PHONE_NUMBER>.
3.) The videos should be fun, but not disparaging. They should adhere to Enron's values of respect, integrity, communication and excellence.
4.) By Monday, October 15, business units need to notify me of their intention to submit a video. To avoid duplication, business units will also need to identify a topic they intend to address.
5.) To ensure inclusion in the Management Conference agenda, videos need to be submitted to me by Friday, November 9.
6.) Awards will be given for creativity and humor. The first annual, and soon-to-be-coveted, "Enny" will also be awarded for "Best Overall Video."
If you have any questions about the "Home Video" project, please contact myself or Mary Clark.
Terrie James
ph.<PHONE_NUMBER>
<EMAIL_ADDRESS>Mary Clark
ph.<PHONE_NUMBER>
<EMAIL_ADDRESS>Good luck and happy filming!
Terrie James
***********
EDRM Enron Email Data Set has been produced in EML, PST and NSF format by ZL Technologies, Inc. This Data Set is licensed under a Creative Commons Attribution 3.0 United States License <http://creativecommons.org/licenses/by/3.0/us/> . To provide attribution, please cite to "ZL Technologies, Inc. (http://www.zlti.com)."
***********
California


Maestro Nikola:
One more thing... The map I gave you is worth my life. Please return it after you use it.