This page is a high-level overview of Rhovas that covers most of the important constructs/features. While there are some specific details and motivation included, most of this information will be covered in other pages rather than here in the overview.
Language constructs are the different expressions, statements, and components used to structure a Rhovas program.
Rhovas supports many of the standard literal types seen in other languages, including different number bases/notations, escape characters, and interpolation.
- Null:
null
- Boolean:
true
,false
- Integer:
42
,0xFFA500
- Decimal:
101.5
,6.022e23
- String:
"string"
,"\n\r\t"
,"val = ${val}"
- Atom:
:atom
- List:
[x, y, z]
- Object:
{x: 1, y: 2, z: 3}
,{x, y, z}
Notably missing are Character literals, since the concept of a character is not well-defined and varies between languages (e.g. Swift and Rust). Instead, it is likely Rhovas will support separate types for working with graphemes and/or code points as needed.
Additionally, it's worth calling attention to atoms as they're less common. Atoms (or sometimes Symbols) are effectively runtime values for identifiers and can be used as named constants. Rhovas encourages using atoms for option-like function parameters instead of booleans or custom enums, as in:
range(1, 100, :incl);
File.open("file.txt", :read, :write);
Rhovas supports most standard unary/binary operators and two indexing operators.
-
Unary:
!
: Logical Negation-
: Numerical Negation
-
Binary:
-
+
,-
,*
,/
: Mathematical (supports operator overloading) -
<
,<=
,>
,>=
: Comparison (supports operator overloading viaComparable
) -
==
,!=
: Equality (supports operator overloading viaEquatable
) -
===
,!==
: Identity Equality -
&&
,||
: Logical And/Or
-
-
Indexing:
-
[]
: Access (supports operator overloading) -
[]=
: Assignment (supports operator overloading)
-
There are a few categories of operators not included primarily for readability, ease of understanding,
and/or having ambiguous behavior: %
(modulus/remainder),
+=
/-=
/*=
//=
(compound assignment), ++
/--
(increment/decrement), <<
/>>
/&
/|
/^
(bitwise). Operators with necessary functionality like modulus or left shift instead have methods on the
types that support them.
Rhovas supports operator overloading for a limited subset of operators: +
,
-
, *
, /
,
[]
, and []=
(as well as indirectly
for comparison/equality). Defining an overload requires both the operator and a descriptive name for that
type to assist clarity (e.g. Vector op+ add
versus Set op+ union
).
It is generally better to prefer using these names when not in a math-heavy context.
struct Vector {
var x: Integer;
var y: Integer;
func op+ add(other: Vector): Vector { ... }
}
Variables are defined with val
(immutable) orvar
(mutable). Type inference is supported with an initial value, otherwise the type must be specified.
Shadowing variables is also allowed.
val x = 1;
var y: Integer;
y = 2;
The intention is for variable declarations to also support pattern matching, however this has some design quirks and hasn't been finalized.
Functions are defined with func
and require a name, parameters, and a
return type (if not Void
) to be explicitly specified. Type inference is
not supported to prevent implementation types from leaking into the API.
func add(x: Integer, y: Integer): Integer {
return x + y;
}
Functions also support a wide mix of other features including overloading, generics, default arguments,
mutability permissions, and throws
declarations for exceptions. As with
variables, the intention is for function parameters to support pattern matching as well however this hasn't
been finalized.
Lambdas (anonymous functions) are also supported. They can be written directly using func
,
but more commonly are created implicitly through trailing lambdas which are passed to other functions.
Type inference is supported for both the parameters and return type.
numbers.map(func(num) { num + 1 })
numbers.map |num| { num + 1 }
The implicit parameter val
(like Kotlin it
)
can also be used for referencing lambda arguments, which is either the single argument itself or a struct
of multiple arguments.
numbers.filter { val > 0 }
numbers.reduce(0) { val.accumulator + val.element }
If statements allow branching based on a condition, as in most other languages.
if (condition) { ... }
if (condition) { ... } else { ... }
Unlike other languages, if
can also be used as a functional form to
filter values into a nullable result.
1.if { val > 0 } == 1;
0.if { val > 0 } == null;
Match statements have two forms: conditional (if
/else
chains) and structural (pattern matching).
A conditional match contains multiple arbitrary conditions in the same was as if
/else
chains. Conditions do not have to be exhaustive, so the else
case is
optional and acts like an assertion.
match {
x > 0: print("x is positive");
else y > 0: print("y is positive");
//if neither is true, an AssertionError is thrown
}
A structural match takes an argument and applies pattern matching. Unlike conditional match, a structural
match must be exhaustive. The else
case can be used when the compiler
is not able to verify the patterns are exhaustive, which as above acts like an assertion.
match (list) {
[]: print("empty");
else [head, *]: print("head = ${head}");
}
A for loop iterates over an iterable value, as with foreach
loops in
most other languages.
for (val element in iterable) { ... }
Like if
, for
can be used as a
functional form as well.
iterable.for { ... }
Rhovas, like Kotlin, does not support the traditional three-part for loop. In most cases iterating over
ranges is a better alternative (like list.indices
) and for other
situations a while
loop may be used.
A while loop repeatedly executes code while a condition is true, as in most other languages.
while (condition) { ... }
A do
/while
loop does not currently
exist, though will likely be supported.
A try statement is used to catch exceptions or ensure certain cleanup occurs, as in most other languages.
Multiple catch
blocks are supported, and at least one catch
/finally
block must be defined.
try { ... } catch (val e: Exception) { ... }
try { ... } finally { ... }
A with statement is used for managing the automatic acquisition and release of resources. Resources are acquired when entering the body and released when exited, including when an exception is thrown.
with (file) { ... }
with (val file = File.open(...)) { ... }
Structs are objects intended to store structured data, as with Kotlin data classes
or Java records. Structs
include default definitions for a constructor, standard methods like equals
/toString
,
and struct transformation utilities like select
/copy
.
struct Vector {
var x: Decimal;
var y: Decimal;
}
val vector = Vector(1.0, 2.0);
Structs can be considered a restricted form of classes with three key differences. First, the fields of a struct are considered part of the API (therefore, adding new fields is a breaking change, unlike classes). Second, a struct cannot maintain invariants between fields since they can be set independently (provided it is mutable). Finally, structs do not support inheritance like classes but can implement interfaces. These restrictions allow structs to support pattern matching and more aggressive optimizations.
Classes are objects supporting the full range of Object-Oriented capabilities, particularly encapsulation and inheritance. Unlike structs, classes are intended to maintain invariants and should only be used if these features are necessary.
class UnitVector {
var x: Decimal { public get }
var y: Decimal { public get }
ensure x * x + y * y == 1.0;
func setDirection(x: Decimal, y: Decimal) {
require x != 0.0 || y != 0.0;
this.x = ...
this.y = ...
}
}
Note: For sake of explicitness, the above example doesn't account for precision and assumes
mutable data is necessary. In most cases, an immutable UnitVector
struct like the previous example would be sufficient for this, or alternatively a better abstraction for
magnitude/direction. Examples are just that - examples!
Classes may also use inheritance to extend (or be extended by) other classes. A class must explicitly
opt-in to inheritance using virtual
or abstract
.
Similarly, only virtual
or abstract
functions can be overridden and must include override
. In general,
inheritance is always opt-in and the superclass must design its API with inheritance in mind to ensure
correct behavior.
abstract class Base {
virtual func method() { ... }
}
class Derived: Base {
override func method() { ... }
}
Language features are the additional ideas and functionality included that make Rhovas, well, Rhovas! These range from high-level concepts down to simple syntax sugar, but are ultimately intended to support the mission of API design and enforcement.
DSLs, or Domain Specific Languages, are languages specifically designed for a given problem/application like regex, SQL, and HTML. Rhovas supports creating embedded DSLs through syntax macros, which allow DSLs to be used directly in Rhovas code with the language's original syntax:
val name = "Name";
db.query(#sql {
SELECT * FROM users
WHERE name = ${name}
}
The example SQL DSL above handles the name
variable through
interpolation, not concatenation, which prevents issues like SQL injection since the variable is never
mixed with the actual source code.
These DSLs are currently transformed into a function taking two arguments: A list of string literals and a list of values (similar to JavaScript Tagged Templates and Scala Interpolators). More advanced transformations are planned but waiting on macro support.
func sql(literals: List<String>, values: List<Any>);
sql(["SELECT * FROM users\nWHERE name = ", ""], [name])
Embedded DSLs are great for problems that already have established DSLs, like SQL, since the syntax is well-known and documented. DSLs for custom languages should be used more sparingly in the same way a framework would (or at least should).
For more information on the theory/research behind syntax macros, see the blog posts Introducing Syntax Macros and Semantic Analysis Abstractions.
Rhovas allows types to include mutability permissions, which provide static restrictions on the mutability of references and the underlying object. There are currently three permissions:
- Readable (
Type
): The reference is read-only, but the object may be mutable. - Mutable (
+Type
): The reference (and therefore object) is mutable. However, the object may also have other mutable references. - Immutable (
-Type
): The object is immutable, thus no mutable references exist. However, the object may reference other objects which are not immutable (such as-List<T>
being an immutable list containing potentially mutable elements), making this shallow immutability.
Two other permissions being discussed are Constant (for deep immutability and compile-time constants) and Unique (for ownership/lifetimes, thread safety, and mutable to immutable conversions).
Methods that mutate the object must be prefixed with +
, as in
func +mutate()
, which may only be used by mutable references.
A related restriction is pure / referentially transparent functions, which is still under discussion.
Another feature from functional languages, pipelining allows a left-hand receiver to be passed as the first argument to a function. The result is similar to the syntax of a method call, as shown below.
function(object, arguments...);
object.|function(arguments...);
Pipelining has two major advantages, mainly due to similarity with methods:
- Readability: The left-to-right order is often easier to understand when chaining
compared to nested functions (
h(g(f()))
vsf().|g().|h()
). - Discoverability: An IDE can offer suggestions for
object.|
, like with methods, to both find and tab-complete available functions.
Some language support extension functions, which allow defining new methods (really functions) on an existing class. Since pipelining syntax is nearly identical to a method call, it works well for this use case.
func extension(object: Any) { ... }
object.|extension()
Note that object.|extension()
is an extension function using
pipelining while object.extension()
is a method. It is important to
keep this syntactic difference for two reasons:
- Extension functions are still functions and are thus resolved statically, not dynamically like methods. This can affect how overloads are resolved, especially considering type inference.
- It is better to keep these scopes separated to avoid API compatability issues from the class adding new methods. This separation also helps IDEs (and the compiler itself) locate definitions easily and provide better support overall.
A property is effectively syntax sugar for getter/setter methods that look like fields. In addition to the benefits from using getters/setters over direct field access, properties are also contained in a single unit (helpful for metaprogramming) and generally represent 'simple' operations.
object.property; //object.property();
object.property = value; //object.property(value);
A common issue raised with properties is that they can perform arbitrary computation, which can make it hard to reason about the effects of getting or setting a property. Rhovas intends on restricting properties to ensure the behavior of getters/setters matches the expectations of fields (such as with side effects, consistency between get/set, etc.). These restrictions are still being determined, but is likely that some cannot be strictly enforced.
For more details on the cost/benefits of properties and potential restrictions, see the blog post A Case for Properties.


System Architect Picture "Resource Type For Activity"
Parent Diagram:
Resource For Activity
(OMT Object Model)


Explained: Three cases of bubonic plague in China; what is it?
Plague has killed tens of millions of people around the world in three major pandemics, with about a third of Europe's population wiped out in the 1300s by bubonic plague, known as the Black Death.
by ReutersChina reported a third case of bubonic plague on Sunday after two other plague cases were revealed last week, but the disease remains rare despite its fearsome reputation and authorities say the cases appear unrelated.
How does the infection occur?
Two patients from Inner Mongolia were quarantined in Beijing suffering from pneumonic plague, authorities said last week. A 55-year old man from the same region was later diagnosed with bubonic plague after eating wild rabbit meat, the health commission said.
Both types of plague are caused by the Yersinia pestis bacterium.
Bites from infected fleas are the most common cause of bubonic plague infection, but the pneumonic variant — where the bacterium is breathed into the lungs — is more dangerous because it is spread through coughing.
A rarer third variant of the diseases is septicaemic plague, which infects the bloodstream.
What are the risks?
Plague has killed tens of millions of people around the world in three major pandemics, with about a third of Europe’s population wiped out in the 1300s by bubonic plague, known as the Black Death.
The bacterium is believed to have originated in Yunnan in southwest China, where it remains endemic. Opium trade routes from Yunnan caused the third global plague outbreak in 1894, but it has since become increasingly rare.
Between 2010 and 2015 there were 3,248 cases worldwide, leading to 584 deaths – a fatality rate of 18%, according to the World Health Organization.
From 2009 to 2018, China reported just 26 cases and 11 deaths. By comparison, there were 12,082 cases of rabies over the same period, with a fatality rate of 96%.
The China Center for Disease Control said the plague is “an ancient bacterial infection that can be treated clinically with a variety of effective antibiotics” if caught early.
Is plague linked to climate change?
The spread of plague in the 1300s has been linked by scientists to unstable climate conditions that caused the disease to evolve and spread more quickly to rats, fleas and humans.
Floods also contributed to the disease’s rapid spread via new water routes.
China says climate change has caused an increase in rodent populations throughout Inner Mongolia. A combination of heavier rainfall followed by longer summer droughts has allowed rats to thrive.
Are there still risks?
China remains concerned about the risk of outbreaks as formerly remote plague-prone rural regions are integrated into the national economy.
The Center for Disease Control says Yunnan and the Qinghai-Tibet plateau in the far west are particularly vulnerable.
Qinghai officials said earlier this year the risk of plague spreading to regions with high population densities had increased because of urbanisation, new infrastructure and tourism.
Infectious diseases are also a sensitive issue for Beijing after an outbreak of Severe Acute Respiratory Syndrome (SARS) in 2003, which many blamed on the failure by authorities to disclose information in a timely manner.


| Package | Description |
|---|---|
| org.nd4j.nativeblas |
| Modifier and Type | Class and Description |
|---|---|
static class |
Nd4jCpu.absolute_difference_loss
Implementation of Absolute Difference loss function |predictions - labels|
Input arrays:
0: predictions - the predicted values, type float.
1: weights - is used for weighting (multiplying) of loss values, type float.
|
static class |
Nd4jCpu.absolute_difference_loss_grad |
static class |
Nd4jCpu.add
This is one of auto-broadcastable operations.
|
static class |
Nd4jCpu.add_bp |
static class |
Nd4jCpu.argmax
This operation returns index of max element in a given NDArray (optionally: along given dimension(s))
Expected input:
0: N-dimensional array
1: optional axis vector
Int args:
0: optional axis
|
static class |
Nd4jCpu.argmin
This operation returns index of min element in a given NDArray (optionally: along given dimension(s))
Expected input:
0: N-dimensional array
1: optional axis vector
Int args:
0: optional axis
|
static class |
Nd4jCpu.assign
This is one of auto-broadcastable operations.
|
static class |
Nd4jCpu.assign_bp |
static class |
Nd4jCpu.avgpool2d
This op implements average pooling for convolution networks.
|
static class |
Nd4jCpu.avgpool2d_bp |
static class |
Nd4jCpu.avgpool3dnew |
static class |
Nd4jCpu.avgpool3dnew_bp |
static class |
Nd4jCpu.batch_to_space |
static class |
Nd4jCpu.batch_to_space_nd |
static class |
Nd4jCpu.batched_gemm
This operation implements batched matrix multiplication
Expected arguments:
alpha: vector of T
beta: vector of T
...: A, B matrices sequentially. i.e: AAAAABBBBB
Integer arguments:
transA, transB, M, N, K, ldA, ldB, ldC - usual BLAS gemm arguments
batchCount - number of operations in this batch
PLEASE NOTE: M, N, K, ldA, ldB, ldC should be equal for all matrices within batch.
|
static class |
Nd4jCpu.batchnorm
Batch normalization implementation.
|
static class |
Nd4jCpu.batchnorm_bp
back prop in batch normalization
Expected arguments:
input: input array (any number of dimensions)
mean:
variance:
gamma: optional
beta: optional
dLdOut: next epsilon
Int args:
0: apply scale
1: apply offset
T args:
0: epsilon
output arrays:
dL/dInput
dL/dMean
dL/dVariance
dL/dGamma, optional
dL/dBeta, optional
|
static class |
Nd4jCpu.biasadd
This operation is added for compatibility purposes mostly.
|
static class |
Nd4jCpu.biasadd_bp |
static class |
Nd4jCpu.bincount
bincount operation return a vector with element counted.
|
static class |
Nd4jCpu.bitcast
This operation change type of input and modified shape of output to conform with given data type
all as above op
|
static class |
Nd4jCpu.bits_hamming_distance
This operation returns hamming distance based on bits
PLEASE NOTE: This operation is applicable only to integer data types
\tparam T
|
static class |
Nd4jCpu.bitwise_and
This operation applies bitwise AND
PLEASE NOTE: This operation is applicable only to integer data types
\tparam T
|
static class |
Nd4jCpu.bitwise_or
This operation applies bitwise OR
PLEASE NOTE: This operation is applicable only to integer data types
\tparam T
|
static class |
Nd4jCpu.bitwise_xor
This operation applies bitwise XOR
PLEASE NOTE: This operation is applicable only to integer data types
\tparam T
|
static class |
Nd4jCpu.boolean_and |
static class |
Nd4jCpu.boolean_or |
static class |
Nd4jCpu.boolean_xor |
static class |
Nd4jCpu.broadcast_dynamic_shape
broadcast_dynamic_shape op.
|
static class |
Nd4jCpu.broadcast_to
This op broadcast given input up to given shape
inputs:
input array - array to be broadcasted to given shape
shape array - array containing shape be broadcasted to
|
static class |
Nd4jCpu.BroadcastableBoolOp
Copyright (c) 2015-2018 Skymind, Inc.
|
static class |
Nd4jCpu.BroadcastableOp
Copyright (c) 2015-2018 Skymind, Inc.
|
static class |
Nd4jCpu.cast
This operation casts elements of input array to specified data type
PLEASE NOTE: This op is disabled atm, and reserved for future releases.
|
static class |
Nd4jCpu.check_numerics
This op checks for Inf/NaN values within input array, and throws exception if there's at least one
|
static class |
Nd4jCpu.choose
This op takes either 1 argument and 1 scalar
or 1 argument and another comparison array
and runs a pre defined conditional op.
|
static class |
Nd4jCpu.clip_by_global_norm
clip a list of given tensors with given average norm when needed
Input:
a list of tensors (at least one)
Input floating point argument:
clip_norm - a value that used as threshold value and norm to be used
return a list of clipped tensors
and global_norm as scalar tensor at the end
|
static class |
Nd4jCpu.clipbyavgnorm_bp |
static class |
Nd4jCpu.clipbynorm_bp |
static class |
Nd4jCpu.col2im
This op implements col2im algorithm, widely used in convolution neural networks
Input: 6D input expected (like output of im2col op)
Int args:
0: stride height
1: stride width
2: padding height
3: padding width
4: image height
5: image width
6: dilation height
7: dilation width
|
static class |
Nd4jCpu.compare_and_bitpack
compare_and_bitpack - compare with greater and pack result with uint8
input params:
0 - NDArray (input)
1 - 0D Tensor - threshold
output:
0 - NDArray with the same shape as input and type uint8
|
static class |
Nd4jCpu.concat |
static class |
Nd4jCpu.concat_bp |
static class |
Nd4jCpu.confusion_matrix
This operation calculate the confusion matrix for a
pair of prediction and label 1-D arrays.
|
static class |
Nd4jCpu.conv1d
1D temporal convolution implementation
Expected input:
x: 3D array
weight: 3D Array
bias: optional vector
Int args:
0: kernel
1: stride
2: padding
|
static class |
Nd4jCpu.conv1d_bp |
static class |
Nd4jCpu.conv2d
2D convolution implementation
Expected input:
x: 4D array
weight: 4D Array
bias: optional vector, length of outputChannels
IntArgs:
0: kernel height
1: kernel width
2: stride height
3: stride width
4: padding height
5: padding width
6: dilation height
7: dilation width
8: same mode: 1 true, 0 false
9: data format: 1 NHWC, 0 NCHW
|
static class |
Nd4jCpu.conv2d_bp |
static class |
Nd4jCpu.conv2d_input_bp |
static class |
Nd4jCpu.conv3dnew |
static class |
Nd4jCpu.conv3dnew_bp |
static class |
Nd4jCpu.cosine_distance_loss
Implementation of cosine-distance loss function 1. - (predictions * labels).reduce_sum_along(dimension)
Input arrays:
0: predictions - the predicted values, type float
1: weights - is used for weighting (multiplying) of loss values, type float.
|
static class |
Nd4jCpu.cosine_distance_loss_grad |
static class |
Nd4jCpu.create
This operation creates new array
Input:
array with shape values
IArgs:
order value
data type value
BArgs:
initialization option
|
static class |
Nd4jCpu.crelu
This is Concatenated RELU implementation.
|
static class |
Nd4jCpu.crelu_bp |
static class |
Nd4jCpu.crop_and_resize
This op make bilinear or nearest neighbor interpolated resize for given tensor
input array:
0 - 4D-Tensor with shape (batch, sizeX, sizeY, channels) numeric type
1 - 2D-Tensor with shape (num_boxes, 4) float type
2 - 1D-Tensor with shape (num_boxes) int type
3 - 1D-Tensor with 2 values (newWidth, newHeight) (optional) int type
float arguments (optional)
0 - exprapolation_value (optional) default 0.f
int arguments: (optional)
0 - mode (default 0 - bilinear interpolation)
output array:
the 4D-Tensor with resized to crop_size images given - float type
|
static class |
Nd4jCpu.cumprod_bp |
static class |
Nd4jCpu.cumsum_bp |
static class |
Nd4jCpu.cyclic_rshift_bits
This operation shift individual bits of each element in array, shifting to the right
PLEASE NOTE: This operation is applicable only to integer data types
\tparam T
|
static class |
Nd4jCpu.cyclic_shift_bits
This operation shift individual bits of each element in array, shifting to the left
PLEASE NOTE: This operation is applicable only to integer data types
\tparam T
|
static class |
Nd4jCpu.deconv2d
2D deconvolution implementation
IntArgs:
0: kernel height
1: kernel width
2: stride height
3: stride width
4: padding height
5: padding width
6: dilation height
7: dilation width
8: same mode: 0 false, 1 true
|
static class |
Nd4jCpu.deconv2d_bp |
static class |
Nd4jCpu.deconv2d_tf |
static class |
Nd4jCpu.deconv3d
3D deconvolution implementation
IntArgs:
0: filter(kernel) depth
1: filter(kernel) height
2: filter(kernel) width
3: strides depth
4: strides height
5: strides width
6: paddings depth
7: paddings height
8: paddings width
9: dilations depth
10: dilations height
11: dilations width
12: same mode: 0 false, 1 true
13: data format (optional): 0-NDHWC, 1-NCDHW, default is 1
|
static class |
Nd4jCpu.deconv3d_bp |
static class |
Nd4jCpu.depth_to_space
This operation rearranges data from depth into blocks of spatial data.
|
static class |
Nd4jCpu.depthwise_conv2d |
static class |
Nd4jCpu.depthwise_conv2d_bp |
static class |
Nd4jCpu.diag
Returns a diagonal tensor with a given diagonal values.
|
static class |
Nd4jCpu.diag_part
Returns a diagonal tensor with a given diagonal values.
|
static class |
Nd4jCpu.dilation2d
Dilation2D op
Int args:
0: isSameMode
|
static class |
Nd4jCpu.divide
This is one of auto-broadcastable operations.
|
static class |
Nd4jCpu.divide_bp |
static class |
Nd4jCpu.divide_no_nan
This is one of auto-broadcastable operations.
|
static class |
Nd4jCpu.dot_product_attention
This operation performs dot product attention on the given timeseries input with the given queries
out = sum(similarity(k_i, q) * v_i)
similarity(k, q) = softmax(k * q) where x * q is the dot product of x and q
Optionally with normalization step:
similarity(k, q) = softmax(k * q / sqrt(size(q))
See also "Attention is all you need" (https://arxiv.org/abs/1706.03762, p. 4, eq. 1)
Note: This supports multiple queries at once, if only one query is available the queries vector still has to
be 3D but can have queryCount = 1
Note: keys and values usually is the same array.
|
static class |
Nd4jCpu.dot_product_attention_bp |
static class |
Nd4jCpu.dynamic_bidirectional_rnn
Implementation of operation "static RNN time sequences" with peep hole connections:
Input arrays:
0: input with shape [time x batchSize x inSize] or [batchSize x time x inSize], time - number of time steps, batchSize - batch size, inSize - number of features
1: input-to-hidden weights for forward RNN, [inSize x numUnitsFW]
2: hidden-to-hidden weights for forward RNN, [numUnitsFW x numUnitsFW]
3: biases for forward RNN, [2*numUnitsFW]
4: input-to-hidden weights for backward RNN, [inSize x numUnitsBW]
5: hidden-to-hidden weights for backward RNN, [numUnitsBW x numUnitsBW]
6: biases for backward RNN, [2*numUnitsBW]
7: (optional) initial cell output for forward RNN [batchSize x numUnitsFW], that is at time step = 0
8: (optional) initial cell output for backward RNN [batchSize x numUnitsBW], that is at time step = 0
9: (optional) vector with shape [batchSize] containing integer values within [0,time), each element of this vector set max time step per each input in batch, this provides no calculations for time >= maxTimeStep
Input integer arguments:
0: (optional) timeMajor - if non zero then input shape is [time, batchSize, ...], else [batchSize, time, ...]
|
static class |
Nd4jCpu.dynamic_partition
dynamic_partition - partition a input tensor onto num_partitions
accordingly to index array given.
|
static class |
Nd4jCpu.dynamic_partition_bp |
static class |
Nd4jCpu.dynamic_rnn
Implementation of operation "static RNN time sequences" with peep hole connections:
Input arrays:
0: input with shape [time x batchSize x inSize] or [batchSize x time x numUnits], time - number of time steps, batchSize - batch size, inSize - number of features
1: input-to-hidden weights, [inSize x numUnits]
2: hidden-to-hidden weights, [numUnits x numUnits]
3: biases, [2*numUnits]
4: (optional) initial cell output [batchSize x numUnits], that is at time step = 0
5: (optional) vector with shape [batchSize] containing integer values within [0,time), each element of this vector set max time step per each input in batch, this provides no calculations for time >= maxTimeStep
Input integer arguments:
0: (optional) timeMajor - if non zero then input shape is [time, batchSize, ...], else [batchSize, time, ...]
|
static class |
Nd4jCpu.dynamic_stitch
dynamic_stitch - merge partitions from the second param a input tensor
into a single tensor accordingly to index array given.
|
static class |
Nd4jCpu.embedding_lookup
embedding_lookup - search for submatrices in given matrix and retunts them
accordingly to index array given.
|
static class |
Nd4jCpu.equals
This op takes 2 equally shaped arrays as input, and provides binary matrix as output.
|
static class |
Nd4jCpu.evaluate_reduction_shape |
static class |
Nd4jCpu.expand_dims |
static class |
Nd4jCpu.expose
This operations exposes given arguments as it's own outputs, but does it only once.
|
static class |
Nd4jCpu.extract_image_patches
extract_image_patches op - Extract patches from images and put them in the "depth" output dimension.
|
static class |
Nd4jCpu.eye
creates identity 2D matrix or batch of identical 2D identity matrices
Input array:
provide some array - in any case operation simply neglects it
Input float argument (if passed):
TArgs[0] - type of elements of output array, default value is 5 (float)
Input integer arguments:
IArgs[0] - order of output identity matrix, 99 -> 'c'-order, 102 -> 'f'-order
IArgs[1] - the number of rows in output inner-most 2D identity matrix
IArgs[2] - optional, the number of columns in output inner-most 2D identity matrix, if this argument is not provided then it is taken to be equal to number of rows
IArgs[3,4,...] - optional, shape of batch, output matrix will have leading batch dimensions of this shape
|
static class |
Nd4jCpu.fill
This operation takes shape as first argument, and returns new NDArray filled with specific scalar value.
|
static class |
Nd4jCpu.firas_sparse
Copyright (c) 2015-2018 Skymind, Inc.
|
static class |
Nd4jCpu.flatten |
static class |
Nd4jCpu.floordiv
This is one of auto-broadcastable operations.
|
static class |
Nd4jCpu.floordiv_bp |
static class |
Nd4jCpu.floormod
This is one of auto-broadcastable operations.
|
static class |
Nd4jCpu.floormod_bp |
static class |
Nd4jCpu.fused_batch_norm
This operation performs batch normalization of layer, it is based on following article https://arxiv.org/abs/1502.03167.
|
static class |
Nd4jCpu.gather |
static class |
Nd4jCpu.gather_nd |
static class |
Nd4jCpu.get_seed |
static class |
Nd4jCpu.greater
This op takes 2 equally shaped arrays as input, and provides binary matrix as output.
|
static class |
Nd4jCpu.greater_equal
This op takes 2 equally shaped arrays as input, and provides binary matrix as output.
|
static class |
Nd4jCpu.gru
Implementation of gated Recurrent Unit:
Input arrays:
0: input with shape [time x batchSize x inSize], time - number of time steps, batchSize - batch size, inSize - number of features
1: initial cell output [batchSize x numUnits], that is at time step = 0
2: input-to-hidden weights, [inSize x 3*numUnits]
3: hidden-to-hidden weights, [numUnits x 3*numUnits]
4: biases, [3*numUnits]
Output arrays:
0: cell outputs [time x batchSize x numUnits], that is per each time step
|
static class |
Nd4jCpu.gru_bp |
static class |
Nd4jCpu.gruCell
Implementation of gated Recurrent Unit cell:
Kyunghyun Cho, Bart van Merrienboer, Caglar Gulcehre, Dzmitry Bahdanau, Fethi Bougares, Holger Schwenk, Yoshua Bengio
"Learning Phrase Representations using RNN Encoder-Decoder for Statistical Machine Translation"
Input arrays:
0: input with shape [batchSize x inSize], batchSize - batch size, inSize - number of features
1: previous cell output [batchSize x numUnits], that is at previous time step t-1
2: RU weights - [(inSize+numUnits), 2*numUnits] - reset and update gates (input/recurrent weights)
3: C weights - [(inSize+numUnits), numUnits] - cell gate (input/recurrent weights)
4: reset and update biases, [2*numUnits] - reset and update gates
5: cell biases, [numUnits]
Output arrays:
0: Reset gate output [bS, numUnits]
1: Update gate output [bS, numUnits]
2: Cell gate output [bS, numUnits]
3: Current cell output [bS, numUnits]
|
static class |
Nd4jCpu.gruCell_bp |
static class |
Nd4jCpu.hashcode
This operation calculates hash code, optionally along dimension
|
static class |
Nd4jCpu.hinge_loss
Implementation of hinge loss function max(0, 1 - labels*logits)
Input arrays:
0: logits - logits, type float
1: weights - is used for weighting (multiplying) of loss values, type float.
|
static class |
Nd4jCpu.hinge_loss_grad |
static class |
Nd4jCpu.histogram
This operation calculates number of entries per bin
|
static class |
Nd4jCpu.histogram_fixed_width
returns histogram (as 1D array) with fixed bins width
Input arrays:
- input array with elements to be binned into output histogram
- range array with first element being bottom limit and second element being top limit of histogram,
please note that input_value <= range[0] will be mapped to histogram[0], input_value >= range[1] will be mapped to histogram[-1]
Input integer arguments:
nbins (optional) - number of histogram bins, default value is 100
|
static class |
Nd4jCpu.huber_loss
Implementation of Huber loss function:
0.5 * (labels-predictions)^2 if |labels-predictions| <= delta
0.5 * delta^2 + delta * (|labels-predictions| - delta) if |labels-predictions| > delta
Input arrays:
0: predictions - the predicted values, type float
1: weights - is used for weighting (multiplying) of loss values, type float.
|
static class |
Nd4jCpu.huber_loss_grad |
static class |
Nd4jCpu.identity_n
This is Indentity operation.
|
static class |
Nd4jCpu.igamma
Broadcastable igamma implementation
igamma(a, x) = gamma(а, x) / Gamma(a) - Gamma distribution function P(a,x)
Gamma(a) = int from 0 to infinity { t ^ {a - 1} e^{-t}dt }
gamma(a, x) = int from 0 to x { t ^ {a - 1} e^{-t}dt }
\tparam T
|
static class |
Nd4jCpu.igammac
Broadcastable igammac implementation
igammac(a, x) = Gamma(a,x)/Gamma(а) - Gamma distribution function Q(a,x)
Gamma(a) = int from 0 to infinity { t ^ {a - 1} e^{-t}dt }
Gamma(a, x) = int from x to infinity { t ^ {a - 1} e^{-t}dt }
\tparam T
|
static class |
Nd4jCpu.im2col
This op implements im2col algorithm, widely used in convolution neural networks
Input: 4D input expected
Int args:
0: kernel height
1: kernel width
2: stride height
3: stride width
4: padding height
5: padding width
6: dilation height
7: dilation width
8: isSameMode
|
static class |
Nd4jCpu.im2col_bp |
static class |
Nd4jCpu.image_resize
This op make interpolated resize for given tensor with given algorithm.
|
static class |
Nd4jCpu.in_top_k
in_top_k operation returns a vector of k boolean values for
given NDArray as 2D matrix of predicted in the NDArray k top values
The first parameter is a NDArray of predicted values (2d array).
|
static class |
Nd4jCpu.l2_loss
l2_loss op.
|
static class |
Nd4jCpu.layer_norm_bp |
static class |
Nd4jCpu.less
This op takes 2 equally shaped arrays as input, and provides binary matrix as output.
|
static class |
Nd4jCpu.less_equal
This op takes 2 equally shaped arrays as input, and provides binary matrix as output.
|
static class |
Nd4jCpu.lin_space
lin_space - op porting from TF (https://www.tensorflow.org/api_docs/python/tf/lin_space)
optional input params:
0 - startVal - NDArray scalar (float point)
1 - finishVal - NDArray scalar (float point)
2 - numOfElements - NDArray scalar (integer)
Optional:
T args
0 - startVal
1 - finishVal]
2 - numOfElements
output:
0 - 1D NDArray with the same type as input and length as given with numOfElements param.
|
static class |
Nd4jCpu.listdiff
This operation takes 2 arrays: original values, and values to be excluded.
|
static class |
Nd4jCpu.log_loss
Implementation of logarithmic loss function ( y_i * log(p_i) + (1 - y_i) * log(1 - p_i) )
Input arrays:
0: predictions - the predicted values, type float
1: weights - is used for weighting (multiplying) of loss values, type float.
|
static class |
Nd4jCpu.log_loss_grad |
static class |
Nd4jCpu.log_matrix_determinant
log_matrix_determinant op.
|
static class |
Nd4jCpu.log_poisson_loss
This op calculates logarithmic loss of poisson distributed input.
|
static class |
Nd4jCpu.log_poisson_loss_grad |
static class |
Nd4jCpu.logdet
logdet op.
|
static class |
Nd4jCpu.lstm
Implementation of operation "LSTM time sequences" with peep hole connections:
Input arrays:
0: input with shape [time x batchSize x inSize], time - number of time steps, batchSize - batch size, inSize - number of features
1: initial cell output [batchSize x numProj], that is at time step = 0, in case of projection=false -> numProj=numUnits!!!
|
static class |
Nd4jCpu.lstmBlock
Implementation of operation for LSTM layer with optional peep hole connections.
|
static class |
Nd4jCpu.lstmBlockCell
Implementation of operation for LSTM cell with optional peep hole connections:
S.
|
static class |
Nd4jCpu.lstmCell
Implementation of operation for LSTM cell with peep hole connections:
S.
|
static class |
Nd4jCpu.lstmLayer |
static class |
Nd4jCpu.lstmLayer_bp |
static class |
Nd4jCpu.lstmLayerCell |
static class |
Nd4jCpu.lstmLayerCellBp |
static class |
Nd4jCpu.lstsq
matrix_solve_ls op (lstsq) - solves one or more linear least-squares problems.
|
static class |
Nd4jCpu.lu
lu op. - make LUP decomposition of given batch of 2D square matricies
input params:
0 - float tensor with dimension (x * y * z * ::: * M * M)
return value:
0 - float tensor with dimension (x * y * z * ::: * M * M) with LU M x M matricies in it
1 - int (32 or 64) batched vector of permutations with length M - shape (x * y * z * ::: * M)
int argument:
0 - data type of output permutaion vector (int32 or int64), optional, default INT32
|
static class |
Nd4jCpu.matmul
This op is general matmum implementation.
|
static class |
Nd4jCpu.matmul_bp |
static class |
Nd4jCpu.matrix_determinant
matrix_determinant op.
|
static class |
Nd4jCpu.matrix_diag
Inserts elements provided by diagonal array into the main diagonal of innermost matrices of output array,
rest output elements are set to zeros
Input array:
diagonal: array containing elements to be inserted into output array,
following rank condition is present: diagonal_rank = ouput_rank - 1
Output array:
0: is considered as batch of matrices, if for example diagonal array has shape [A,B,C] then output array has shape [A,B,C,C]
|
static class |
Nd4jCpu.matrix_diag_part
Returns a diagonal vector for any submatricies with in a given tensor.
|
static class |
Nd4jCpu.max_pool_with_argmax
This op same as maxpool2d with a variant to return a matrix of indexes for max values
Input - 4D tensor
Output:
0 - 4D tensor as input
1 - 4D tensor with max value indexes
Int params:
9 int with 2x4 vectors and 1 bool value
|
static class |
Nd4jCpu.maximum
This is one of auto-broadcastable operations.
|
static class |
Nd4jCpu.maximum_bp |
static class |
Nd4jCpu.maxpool2d
This op implements max pooling for convolution networks.
|
static class |
Nd4jCpu.maxpool2d_bp |
static class |
Nd4jCpu.maxpool3dnew |
static class |
Nd4jCpu.maxpool3dnew_bp |
static class |
Nd4jCpu.mean_pairwssqerr_loss
Implementation of pairwise-errors-squared loss function
Input arrays:
0: predictions - the predicted values, type float.
1: weights - is used for weighting (multiplying) of loss values, type float.
|
static class |
Nd4jCpu.mean_pairwssqerr_loss_grad |
static class |
Nd4jCpu.mean_sqerr_loss
Implementation of Sum-of-Squares loss function 1/N * sum_{i}^{N}(predictions_i - labels_i)^2
Input arrays:
0: predictions - the predicted values, type float
1: weights - is used for weighting (multiplying) of loss values, type float.
|
static class |
Nd4jCpu.mean_sqerr_loss_grad |
static class |
Nd4jCpu.mergeadd_bp |
static class |
Nd4jCpu.mergeavg_bp |
static class |
Nd4jCpu.mergemax_bp |
static class |
Nd4jCpu.mergemaxindex |
static class |
Nd4jCpu.meshgrid |
static class |
Nd4jCpu.minimum
This is one of auto-broadcastable operations.
|
static class |
Nd4jCpu.minimum_bp |
static class |
Nd4jCpu.mirror_pad |
static class |
Nd4jCpu.mod |
static class |
Nd4jCpu.mod_bp |
static class |
Nd4jCpu.moments
moments operation calculate a mean and variation for given NDArray
with reduce a result according to axis array given.
|
static class |
Nd4jCpu.multi_head_dot_product_attention
This performs multi-headed dot product attention on the given timeseries input
out = concat(head_1, head_2, ..., head_n) * Wo
head_i = dot_product_attention(Wq_i*q, Wk_i*k, Wv_i*v)
Optionally with normalization when calculating the attention for each head.
|
static class |
Nd4jCpu.multi_head_dot_product_attention_bp |
static class |
Nd4jCpu.multiply
This is one of auto-broadcastable operations.
|
static class |
Nd4jCpu.multiply_bp |
static class |
Nd4jCpu.non_max_suppression
image.non_max_suppression ops.
|
static class |
Nd4jCpu.non_max_suppression_overlaps |
static class |
Nd4jCpu.non_max_suppression_v3 |
static class |
Nd4jCpu.normalize_moments
normalize_moments operation normalize already calculated mean and variation
accordingly to shift and count.
|
static class |
Nd4jCpu.not_equals
This op takes 2 equally shaped arrays as input, and provides binary matrix as output.
|
static class |
Nd4jCpu.nth_element |
static class |
Nd4jCpu.onehot
This operation return one-hot encoded n-dimensional array
Expected arguments:
input: N-dimensional array
T args:
0: 'on' value
1: 'off' value
Int args:
0: depth
1: axis
|
static class |
Nd4jCpu.ones_as
This operation takes input's shape, and returns new NDArray filled with ones
Expected arguments:
input: N-dimensional array
|
static class |
Nd4jCpu.order
This op changes order of given array to specified order.
|
static class |
Nd4jCpu.pad |
static class |
Nd4jCpu.parallel_stack |
static class |
Nd4jCpu.percentile
This operation performs calculation of percentile of input array along given axises
Input - tensor with rank N > 0
Output - tensor with rank (N - length(axis)) or scalar if number of Integer arguments is zero
Float arguments:
0: percentile (scalar) in range [0,100] (inclusively)
1: interpolation (optional), possible values are 0-"lower", 1-"higher", 2-"nearest"(default)
2: keepDims (optional), if it is non zero, then unities are kept in reduced resulting shape of output array, default is 0
Integer arguments - axis - the sequence of axises to calculate percentile along, if sequence is empty then calculate percentile for whole input tensor and return result as scalar
|
static class |
Nd4jCpu.permute
Copyright (c) 2015-2018 Skymind, Inc.
|
static class |
Nd4jCpu.pnormpool2d
This op implements pnorm pooling for convolution networks.
|
static class |
Nd4jCpu.pnormpool2d_bp |
static class |
Nd4jCpu.pointwise_conv2d
point-wise 2D convolution
Expected input:
x: 4D array
weight: 4D Array [1, 1, iC, oC] (NHWC) or [oC, iC, 1, 1] (NCHW)
bias: optional vector, length of oC
IntArgs:
0: data format: 1 NHWC, 0 NCHW (optional, by default = NHWC)
|
static class |
Nd4jCpu.Pow
Broadcastable pow implementation
\tparam T
|
static class |
Nd4jCpu.Pow_bp |
static class |
Nd4jCpu.qr
QR decomposition: A = QR, where Q is ortogonal (Q * QT = I) and R is upper triangular.
|
static class |
Nd4jCpu.random_bernoulli |
static class |
Nd4jCpu.random_crop |
static class |
Nd4jCpu.random_exponential |
static class |
Nd4jCpu.random_gamma
random_gamma op.
|
static class |
Nd4jCpu.random_multinomial |
static class |
Nd4jCpu.random_normal |
static class |
Nd4jCpu.random_poisson
random_poisson op.
|
static class |
Nd4jCpu.randomuniform |
static class |
Nd4jCpu.range
This operation generate sequences.
|
static class |
Nd4jCpu.rank
This operation returns rank of input array as scalar value.
|
static class |
Nd4jCpu.realdiv
This is one of auto-broadcastable operations.
|
static class |
Nd4jCpu.realdiv_bp |
static class |
Nd4jCpu.reduce_dot_bp
This op calculates backprop dot for two tensors along given dimensions
input array:
x: tensor to calculate dot for
y: tensor to calculate dot for
z: tensor with gradient output of the FF dot for x and y
int arguments:
list of integers - dimensions to calculate dot along,
default corresponds to empty list in which case calculation
is performed for all dimensions and scalar is returned.
|
static class |
Nd4jCpu.reduce_logsumexp
reduce_logsumexp - tf.reduce_logsumexe operation
input params:
0 - NDArray (input)
1 - 1D NDArray (axis) (optional) - integer array
T_ARG param (optional):
0 - keep_dims !
|
static class |
Nd4jCpu.reduce_max
This op calculates max of elements along given dimensions
input array:
x: tensor to calculate maxes for
float arguments:
keepDims: if non zero, then keep reduced dimensions with length = 1, default value is zero
int arguments:
list of integers - dimensions to calculate max along, default corresponds to empty list in which case calculation is performed for all dimensions and scalar is returned
output array:
reduced tensor with calculated maxes
|
static class |
Nd4jCpu.reduce_max_bp |
static class |
Nd4jCpu.reduce_mean
This op calculates mean of elements along given dimensions
input array:
x: tensor to calculate mean for
float arguments:
keepDims: if non zero, then keep reduced dimensions with length = 1, default value is zero
int arguments:
list of integers - dimensions to calculate mean along, default corresponds to empty list in which case calculation is performed for all dimensions and scalar is returned
output array:
reduced tensor with calculated means
|
static class |
Nd4jCpu.reduce_mean_bp |
static class |
Nd4jCpu.reduce_min
This op calculates min of elements along given dimensions
input array:
x: tensor to calculate mins for
float arguments:
keepDims: if non zero, then keep reduced dimensions with length = 1, default value is zero
int arguments:
list of integers - dimensions to calculate min along, default corresponds to empty list in which case calculation is performed for all dimensions and scalar is returned
output array:
reduced tensor with calculated mins
|
static class |
Nd4jCpu.reduce_min_bp |
static class |
Nd4jCpu.reduce_norm_max
This op calculates norm max of elements along given dimensions
input array:
x: tensor to calculate norm max for
float arguments:
keepDims: if non zero, then keep reduced dimensions with length = 1, default value is zero
int arguments:
list of integers - dimensions to calculate norm max along, default corresponds to empty list in which case calculation is performed for all dimensions and scalar is returned
output array:
reduced tensor with calculated norm
|
static class |
Nd4jCpu.reduce_norm_max_bp |
static class |
Nd4jCpu.reduce_norm1
This op calculates norm1 of elements along given dimensions
input array:
x: tensor to calculate norm1 for
float arguments:
keepDims: if non zero, then keep reduced dimensions with length = 1, default value is zero
int arguments:
list of integers - dimensions to calculate norm1 along, default corresponds to empty list in which case calculation is performed for all dimensions and scalar is returned
output array:
reduced tensor with calculated norm1
|
static class |
Nd4jCpu.reduce_norm1_bp |
static class |
Nd4jCpu.reduce_norm2
This op calculates norm2 of elements along given dimensions
input array:
x: tensor to calculate norm2 for
float arguments:
keepDims: if non zero, then keep reduced dimensions with length = 1, default value is zero
int arguments:
list of integers - dimensions to calculate norm2 along, default corresponds to empty list in which case calculation is performed for all dimensions and scalar is returned
output array:
reduced tensor with calculated norm2
|
static class |
Nd4jCpu.reduce_norm2_bp |
static class |
Nd4jCpu.reduce_prod
reduction_prod - tf.reduction_prod operation
input params:
0 - NDArray
T_ARG param (optional):
0 - keep_dims !
|
static class |
Nd4jCpu.reduce_prod_bp |
static class |
Nd4jCpu.reduce_sqnorm
This op calculates squared norm of elements along given dimensions
input array:
x: tensor to calculate squared norm for
float arguments:
keepDims: if non zero, then keep reduced dimensions with length = 1, default value is zero
int arguments:
list of integers - dimensions to calculate squared norm along, default corresponds to empty list in which case calculation is performed for all dimensions and scalar is returned
output array:
reduced tensor with calculated norm
|
static class |
Nd4jCpu.reduce_sqnorm_bp |
static class |
Nd4jCpu.reduce_stdev
This op calculates sample standard deviation of elements along given dimensions
input array:
x: tensor to calculate mean for
float arguments:
keepDims: if non zero, then keep reduced dimensions with length = 1, default value is zero
biasCorrected - if non zero, then bias correction will be applied, default value is zero
int arguments:
list of integers - dimensions to calculate mean along, default corresponds to empty list in which case calculation is performed for all dimensions and scalar is returned
output array:
reduced tensor with calculated means
|
static class |
Nd4jCpu.reduce_stdev_bp |
static class |
Nd4jCpu.reduce_sum
reduction_sum - tf.reduction_sum operation
input params:
0 - NDArray
T_ARG param (optional):
0 - keep_dims !
|
static class |
Nd4jCpu.reduce_sum_bp |
static class |
Nd4jCpu.reduce_variance
This op calculates sample variance of elements along given dimensions
input array:
x: tensor to calculate mean for
float arguments:
keepDims: if non zero, then keep reduced dimensions with length = 1, default value is zero
biasCorrected - if non zero, then bias correction will be applied, default value is zero
int arguments:
list of integers - dimensions to calculate mean along, default corresponds to empty list in which case calculation is performed for all dimensions and scalar is returned
output array:
reduced tensor with calculated means
|
static class |
Nd4jCpu.reduce_variance_bp |
static class |
Nd4jCpu.relu_layer
relu_layer = relu(x*w + b)
|
static class |
Nd4jCpu.repeat |
static class |
Nd4jCpu.reshape |
static class |
Nd4jCpu.reshapeas |
static class |
Nd4jCpu.resize_area
This op make area interpolated resize (as OpenCV INTER_AREA algorithm) for given tensor
input array:
0 - images - 4D-Tensor with shape (batch, sizeX, sizeY, channels)
1 - size - 1D-Tensor with 2 values (newWidth, newHeight) (if missing a pair of integer args should be provided).
|
static class |
Nd4jCpu.resize_bicubic
This op make bicubic interpolated resize for given tensor
input array:
0 - 4D-Tensor with shape (batch, sizeX, sizeY, channels)
1 - 1D-Tensor with 2 values (newWidth, newHeight)
output array:
the 4D-Tensor with resized image (shape is {batch, newWidth, newHeight, channels})
|
static class |
Nd4jCpu.resize_bilinear
This op make bilinear interpolated resize for given tensor
input array:
0 - 4D-Tensor with shape (batch, sizeX, sizeY, channels)
1 - 1D-Tensor with 2 values (newWidth, newHeight) (optional)
int arguments: (optional)
0 - new width
1 - new height
output array:
the 4D-Tensor with calculated backproped dots
CAUTION: either size tensor or a pair of int params should be provided.
|
static class |
Nd4jCpu.resize_nearest_neighbor
This op make nearest neighbor interpolated resize for given tensor
input array:
0 - 4D-Tensor with shape (batch, sizeX, sizeY, channels)
1 - 1D-Tensor with 2 values (newWidth, newHeight) (optional)
int arguments: (optional)
0 - new width
1 - new height
output array:
the 4D-Tensor with resized image (shape is {batch, newWidth, newHeight, channels})
CAUTION: either size tensor or a pair of int params should be provided.
|
static class |
Nd4jCpu.reverse_bp |
static class |
Nd4jCpu.reverse_sequence |
static class |
Nd4jCpu.reversedivide
This is one of auto-broadcastable operations.
|
static class |
Nd4jCpu.reversedivide_bp |
static class |
Nd4jCpu.reversemod
This is one of auto-broadcastable operations.
|
static class |
Nd4jCpu.reversemod_bp |
static class |
Nd4jCpu.reversesubtract
This is one of auto-broadcastable operations.
|
static class |
Nd4jCpu.reversesubtract_bp |
static class |
Nd4jCpu.rshift_bits
This operation shift individual bits of each element in array to the right: >>
PLEASE NOTE: This operation is applicable only to integer data types
\tparam T
|
static class |
Nd4jCpu.scatter_nd
This operation scatter "updates" elements into new output array according to given "indices"
Expected arguments:
indices: array containing elements/slices indexes of output array to put "updates" elements into, the rest output elements will be zeros
updates: array containing elements to be inserted into output array
shape: contains shape of output array
|
static class |
Nd4jCpu.sconv2d
Depthwise convolution2d op:
Expected inputs:
x: 4D array, NCHW format
weightsDepth: 4D array,
weightsPointwise: optional, 4D array
bias: optional, vector
|
static class |
Nd4jCpu.sconv2d_bp |
static class |
Nd4jCpu.segment_max
segment_max op. - make a tensor filled by max values according to index tensor given.
|
static class |
Nd4jCpu.segment_max_bp |
static class |
Nd4jCpu.segment_mean
segment_mean op. - make a tensor filled by average of values according to index tensor given.
|
static class |
Nd4jCpu.segment_mean_bp |
static class |
Nd4jCpu.segment_min
segment_min op. - make a tensor filled by min values according to index tensor given.
|
static class |
Nd4jCpu.segment_min_bp |
static class |
Nd4jCpu.segment_prod
segment_prod op. - make a tensor filled by product of values according to index tensor given.
|
static class |
Nd4jCpu.segment_prod_bp |
static class |
Nd4jCpu.segment_sum
segment_sum op. - make a tensor filled by sum of values according to index tensor given.
|
static class |
Nd4jCpu.segment_sum_bp |
static class |
Nd4jCpu.select
This op takes 2 n-dimensional arrays as input, and return
array of the same shape, with elements, either from x or y, depending on the condition.
|
static class |
Nd4jCpu.sequence_mask
sequence_mask op. - make mask for given tensor filled by (j > x[i_1, i_2,...
|
static class |
Nd4jCpu.set_seed
Copyright (c) 2015-2018 Skymind, Inc.
|
static class |
Nd4jCpu.shape_of |
static class |
Nd4jCpu.shapes_of |
static class |
Nd4jCpu.shift_bits
This operation shift individual bits of each element in array to the left: <<
PLEASE NOTE: This operation is applicable only to integer data types
\tparam T
|
static class |
Nd4jCpu.sigm_cross_entropy_loss
Implementation of sigmoid cross-entropy loss function max(logits, 0.) - logits * labels + log(1. + exp(-abs(logits)));
Input arrays:
0: logits - logits, type float
1: weights - is used for weighting (multiplying) of loss values, type float.
|
static class |
Nd4jCpu.sigm_cross_entropy_loss_grad |
static class |
Nd4jCpu.size
This operation returns length of input array
Expected arguments:
input: N-dimensional array
TODO: make this operation reduction, to allow TAD -> size
|
static class |
Nd4jCpu.size_at |
static class |
Nd4jCpu.slice
This operation extracts a slice from a tensor.
|
static class |
Nd4jCpu.slice_bp |
static class |
Nd4jCpu.softmax_cross_entropy_loss
Implementation of softmax cross-entropy loss function max(logits, 0.) - logits * labels + log(1. + exp(-abs(logits)));
Input arrays:
0: logits - logits, type float
1: weights - is used for weighting (multiplying) of loss values, type float.
|
static class |
Nd4jCpu.softmax_cross_entropy_loss_grad |
static class |
Nd4jCpu.softmax_cross_entropy_loss_with_logits
Implementation of softmax cross-entropy loss function
Input arrays:
0: logits - logits, type float
1: labels - ground truth vales, expected to be 0. or 1., type float.
|
static class |
Nd4jCpu.softmax_cross_entropy_loss_with_logits_grad |
static class |
Nd4jCpu.solve
solve op. - solve systems of linear equations - general method.
|
static class |
Nd4jCpu.solve_ls |
static class |
Nd4jCpu.space_to_batch
Zero-pads and then rearranges (permutes) blocks of spatial data into batch.
|
static class |
Nd4jCpu.space_to_batch_nd |
static class |
Nd4jCpu.space_to_depth
This operation rearranges blocks of spatial data, into depth.This op output is a copy of the input tensor
where values from the height and width dimensions are moved to the depth dimension.
|
static class |
Nd4jCpu.sparse_softmax_cross_entropy_loss_with_logits
Implementation of sparse softmax cross-entropy loss function
Input arrays:
0: labels - ground truth vales, expected to be within range [0, num_classes), type float.
|
static class |
Nd4jCpu.sparse_softmax_cross_entropy_loss_with_logits_grad |
static class |
Nd4jCpu.split
This operation splits given NDArray into chunks of specific size, along given dimension
0 - input array
1 - optional axis
Integer arguments:
0 - number of splits
1 - optional axis
|
static class |
Nd4jCpu.split_v
This operation splits given NDArray into chunks of specific size, along given dimension
Input arrays:
0 - input array
1 - array of sizes
2 - optional axis
Integer arguments:
0 - optional axis
|
static class |
Nd4jCpu.squaredsubtract
This is one of auto-broadcastable operations.
|
static class |
Nd4jCpu.squaredsubtract_bp |
static class |
Nd4jCpu.squeeze |
static class |
Nd4jCpu.sru
Implementation of operation for Simple Recurrent Unit: "Training RNNs as Fast as CNNs" Tao Lei, Yu Zhang, Yoav Artzi
Input arrays:
0: input 3d tensor with shape [bS x K x N], N - number of time steps, bS - batch size, K - number of features
1: 2d tensor of weights [3K x K]
2: row of biases with twice length [1 x 2K]
3: 2d tensor of previous cell state [bS x K]
4: optional, 2d tensor of dropout mask [bS x K]
Output arrays:
0: 3d tensor of cell output [bS x K x N]
1: 3d tensor of cell state [bS x K x N]
|
static class |
Nd4jCpu.sru_bi
Implementation of operation for Simple Recurrent Unit (bidirectional case): "Training RNNs as Fast as CNNs" Tao Lei, Yu Zhang, Yoav Artzi
Input arrays:
0: input 3d tensor with shape [N x bS x 2K], N - number of time steps, bS - batch size, K - number of features
1: 2d tensor of weights [2K x 6K]
2: row of biases with twice length [1 x 4K]
3: 2d tensor of previous cell state [bS x 2K]
4: optional, 2d tensor of dropout mask [bS x 2K]
Output arrays:
0: 3d tensor of cell output [N x bS x 2K]
1: 3d tensor of cell state [N x bS x 2K]
|
static class |
Nd4jCpu.sru_bi_bp
Implementation of operation for back propagation in Simple Recurrent Unit (bidirectional case): "Training RNNs as Fast as CNNs" Tao Lei, Yu Zhang, Yoav Artzi
Input arrays:
0: input 3d tensor with shape [N x bS x 2K], N - number of time steps, bS - batch size, K - number of features
1: 2d tensor of weights [2K x 6K]
2: row of biases with twice length [1 x 4K]
3: 2d tensor of previous cell state [bS x 2K]
4: 3d tensor of cell state [N x bS x 2K]
5: 2d tensor of cell state gradients [bS x 2K]
6: 3d tensor of state output gradients [N x bS x 2K]
7: optional, 2d tensor of dropout mask [bS x 2K]
Output arrays:
0: 3d tensor of input gradients [N x bS x 2K]
1: 3d tensor of weights gradients [N x 2K x 6K]
2: 2d, row of biases gradients [1 x 4K]
3: 2d, tensor of state gradients [bS x 2K]
|
static class |
Nd4jCpu.sru_bp
Implementation of operation for back propagation in Simple Recurrent Unit: "Training RNNs as Fast as CNNs" Tao Lei, Yu Zhang, Yoav Artzi
Input arrays:
0: input 3d tensor with shape [bS x K x N], N - number of time steps, bS - batch size, K - number of features
1: 2d tensor of weights [3K x K]
2: row of biases with twice length [1 x 2K]
3: 2d tensor of previous cell state [bS x K]
4: 3d tensor of cell state [bS x K x N]
5: 2d tensor of cell state gradients [bS x K]
6: 3d tensor of state output gradients [bS x K x N]
7: optional, 2d tensor of dropout mask [bS x K]
Output arrays:
0: 3d tensor of input gradients [bS x K x N]
1: 3d tensor of weights gradients [bS x 3K x K]
2: 2d, row of biases gradients [1 x 2K]
3: 2d, tensor of state gradients [bS x K]
|
static class |
Nd4jCpu.sruCell
Implementation of operations for Simple Recurrent Unit cell: "Training RNNs as Fast as CNNs" Tao Lei, Yu Zhang, Yoav Artzi
Input arrays:
0: input with shape [batchSize x inSize], batchSize - batch size, inSize - number of features
1: previous cell state [batchSize x inSize], that is at previous time step t-1
2: weights [inSize x 3*inSize]
3: biases [1 x 2*inSize]
Output arrays:
0: current cell output [batchSize x inSize], that is at current time step t
1: current cell state [batchSize x inSize], that is at current time step t
|
static class |
Nd4jCpu.stack
This operation stacks a list of rank tensors into one rank-(R+1) tensor.
|
static class |
Nd4jCpu.standardize_bp |
static class |
Nd4jCpu.static_bidirectional_rnn
Implementation of operation "static RNN time sequences" with peep hole connections:
Input arrays:
0: input with shape [time x batchSize x inSize], time - number of time steps, batchSize - batch size, inSize - number of features
1: input-to-hidden weights for forward RNN, [inSize x numUnitsFW]
2: hidden-to-hidden weights for forward RNN, [numUnitsFW x numUnitsFW]
3: biases for forward RNN, [2*numUnitsFW]
4: input-to-hidden weights for backward RNN, [inSize x numUnitsBW]
5: hidden-to-hidden weights for backward RNN, [numUnitsBW x numUnitsBW]
6: biases for backward RNN, [2*numUnitsBW]
7: (optional) initial cell output for forward RNN [batchSize x numUnitsFW], that is at time step = 0
8: (optional) initial cell output for backward RNN [batchSize x numUnitsBW], that is at time step = 0
9: (optional) vector with shape [batchSize] containing integer values within [0,time), each element of this vector set max time step per each input in batch, this provides no calculations for time >= maxTimeStep
Output arrays:
0: cell outputs [time x batchSize x (numUnitsFW + numUnitsBW)]
1: cell final non-zero output for forward RNN [batchSize x numUnitsFW]
2: cell final non-zero output for backward RNN [batchSize x numUnitsBW]
|
static class |
Nd4jCpu.static_rnn
Implementation of operation "static RNN time sequences" with peep hole connections:
Input arrays:
0: input with shape [time x batchSize x inSize], time - number of time steps, batchSize - batch size, inSize - number of features
1: input-to-hidden weights, [inSize x numUnits]
2: hidden-to-hidden weights, [numUnits x numUnits]
3: biases, [2*numUnits]
4: (optional) initial cell output [batchSize x numUnits], that is at time step = 0
5: (optional) vector with shape [batchSize] containing integer values within [0,time), each element of this vector set max time step per each input in batch, this provides no calculations for time >= maxTimeStep
Output arrays:
0: cell outputs [time x batchSize x numUnits]
1: cell final non-zero output [batchSize x numUnits]
|
static class |
Nd4jCpu.strided_slice
This operation extracts a strided (optionally) slice from a tensor,
|
static class |
Nd4jCpu.strided_slice_bp |
static class |
Nd4jCpu.subtract
This is one of auto-broadcastable operations.
|
static class |
Nd4jCpu.subtract_bp |
static class |
Nd4jCpu.sufficient_statistics
sufficient_statistics operation return calculated mean and variation with data count.
|
static class |
Nd4jCpu.svd
performs singular value decomposition (SVD) of one or more matrices, evaluates the SVD of each inner-most 2D matrix in input array:
x[..., :, :] = u[..., :, :] * s[...,:] * transpose(v[..., :, :])
Input array:
x[..., Rows, Cols], the necessary condition is: rank of x >= 2
Outputs arrays:
s[..., diagSize] - array with singular values which are stored in decreasing order, diagSize is smaller among Rows and Cols
u[..., Rows, Rows] if IArgs[1] is true, else u[..., Rows, diagSize] - array with right singular vectors
v[..., Cols, Cols] if IArgs[1] is true, else v[..., Cols, diagSize] - array with left singular vectors
Integer arguments:
IArgs[0] - bool, whether to calculate u and v, s is calculated in any case
IArgs[1] - bool, whether to calculate full-sized u and v
IArgs[2] - the number of cols or rows which determines what algorithm to use.
|
static class |
Nd4jCpu.tear
This operation splits input NDArray into multiple TADs along given dimensions
Expected arguments:
input: N-dimensional array
Int args:
0..: TAD axis
|
static class |
Nd4jCpu.tensormmul
tensorMmul/tensorDot operation
takes 2 ndarrays, and 2 sets of axes
Integer argumens map:
IArgs[0] - number of axes along for first array
IArgs[1]... axes values for first array
IArgs[] - number of axes along for second array
IArgs[1]... axes values for second array
|
static class |
Nd4jCpu.tensormmul_bp |
static class |
Nd4jCpu.test_scalar |
static class |
Nd4jCpu.testcustom |
static class |
Nd4jCpu.tf_atan2
Special atan2 op impl for TF's args order
\tparam T
|
static class |
Nd4jCpu.tile |
static class |
Nd4jCpu.tile_bp |
static class |
Nd4jCpu.tile_to_shape
This op boosts specified input up to specified shape
\tparam T
|
static class |
Nd4jCpu.tile_to_shape_bp |
static class |
Nd4jCpu.to_double
This operation casts elements of input array to double data type
PLEASE NOTE: This op is disabled atm, and reserved for future releases.
|
static class |
Nd4jCpu.to_float16
This operation casts elements of input array to float16 data type
PLEASE NOTE: This op is disabled atm, and reserved for future releases.
|
static class |
Nd4jCpu.to_float32
This operation casts elements of input array to float data type
PLEASE NOTE: This op is disabled atm, and reserved for future releases.
|
static class |
Nd4jCpu.to_int32
This operation casts elements of input array to int32 data type
PLEASE NOTE: This op is disabled atm, and reserved for future releases.
|
static class |
Nd4jCpu.to_int64
This operation casts elements of input array to int64 (aka long long) data type
PLEASE NOTE: This op is disabled atm, and reserved for future releases.
|
static class |
Nd4jCpu.to_uint32
This operation casts elements of input array to unsinged int32 data type
PLEASE NOTE: This op is disabled atm, and reserved for future releases.
|
static class |
Nd4jCpu.to_uint64
This operation casts elements of input array to unsigned int64 (aka unsigned long long) data type
PLEASE NOTE: This op is disabled atm, and reserved for future releases.
|
static class |
Nd4jCpu.top_k
top_k operation returns a vector of k top values for
given NDArray as tensor with default boolean (true)
as sort for result index array
will be sorted by the values in descending order.
|
static class |
Nd4jCpu.trace |
static class |
Nd4jCpu.transpose |
static class |
Nd4jCpu.tri |
static class |
Nd4jCpu.triangular_solve
triangular_solve op. - reverse Gaussian method for solve systems of linear equations.
|
static class |
Nd4jCpu.triu |
static class |
Nd4jCpu.triu_bp |
static class |
Nd4jCpu.truncatediv
\tparam T
|
static class |
Nd4jCpu.unique
This operation returns unique elements from input array as vector, and their original indices in input array
Expected input:
input: N-dimensional array
|
static class |
Nd4jCpu.unique_with_counts
This operation returns 3 1D arrays for given 1D array with unique element count and indexes
input:
0 - 1D array
output:
0 - 1D array with unique values
1 - 1D array with ids for values in array above
2 - 1D array with counts for values in array above
|
static class |
Nd4jCpu.unsorted_segment_max
unsorted_segment_max op. - make a tensor filled by max values according to index tensor given.
|
static class |
Nd4jCpu.unsorted_segment_max_bp |
static class |
Nd4jCpu.unsorted_segment_mean
unsorted_segment_mean op. - make a tensor filled by average of values according to index tensor given.
|
static class |
Nd4jCpu.unsorted_segment_mean_bp |
static class |
Nd4jCpu.unsorted_segment_min
unsorted_segment_min op. - make a tensor filled by min values according to index tensor given.
|
static class |
Nd4jCpu.unsorted_segment_min_bp |
static class |
Nd4jCpu.unsorted_segment_prod
unsorted_segment_prod op. - make a tensor filled by product of values according to index tensor given.
|
static class |
Nd4jCpu.unsorted_segment_prod_bp |
static class |
Nd4jCpu.unsorted_segment_sqrt_n
unsorted_segment_sqrt_n op. - computes the sum along segments of a tensor divided by the sqrt(N).
|
static class |
Nd4jCpu.unsorted_segment_sqrt_n_bp |
static class |
Nd4jCpu.unsorted_segment_sum
unsorted_segment_sum op. - make a tensor filled by sum of values according to index tensor given.
|
static class |
Nd4jCpu.unsorted_segment_sum_bp |
static class |
Nd4jCpu.unstack
This op does the same as tear, just uses different input format:
\tparam T
|
static class |
Nd4jCpu.upsampling2d
Expected input: 4D array
IntArgs:
0: scale factor for rows (height)
1: scale factor for columns (width)
2: data format: 0 NHWC (default), 1 NCHW
|
static class |
Nd4jCpu.upsampling2d_bp |
static class |
Nd4jCpu.upsampling3d
Expected input: 4D array
IntArgs:
0: scale factor for depth
1: scale factor for rows (height)
2: scale factor for columns (width)
3: data format: 0 NDHWC (default), 1 NCDHW
|
static class |
Nd4jCpu.upsampling3d_bp |
static class |
Nd4jCpu.Where
This op takes 2 n-dimensional arrays as input, and return
array of the same shape, with elements, either from x or y, depending on the condition.
|
static class |
Nd4jCpu.where_np |
static class |
Nd4jCpu.xw_plus_b
xw_plus_b op.
|
static class |
Nd4jCpu.xw_plus_b_bp |
static class |
Nd4jCpu.zero_fraction
zero_fraction op.
|
static class |
Nd4jCpu.zeros_as
This operation takes input's shape, and returns new NDArray filled with zeros
Expected arguments:
input: N-dimensional array
|
Copyright © 2020. All rights reserved.


Show Off
Sign in
Take a moment to tell us about Yourself
@
Topics you are Intrested in
!
E-Topics you want to participate in
!
Your Identity proof (governmental is preferred)
?
Choose File...
fds
Your Profile Picture
Choose File...
0%
I have read community standards and I acknowledge it >


These are the must-read stories from the weekend
by Eyewitness News1. Large water main break causes flooding in streets of Brooklyn
Residents of Sunset Park woke up to quite a mess Sunday morning after a water main break near 5th Avenue and 44th Street sent thousands of gallons of water into the streets.
2.
3. Michael Bloomberg launches Democratic presidential bid
The former New York City mayor, one of the richest men in the world, formally joined the Democratic presidential field on Sunday. The 77-year-old former Republican announced his plans on a campaign website.
4. Police: Landlord-tenant dispute sparks assault that left man unconscious
Muthana Abdulla has weeks of recovery with dozens of staples in his head and numerous large bruises on his body. Police say the attackers used baseball bats and a metal pipe to brutally beat Abdulla just down the sidewalk from his grocery store.
5.  The neighborhood now looks as you would expect it did in 1975 when Jimmy Hoffa disappeared.


This is the Client ID of the Client created in instagram.com/developer. If using a Sandbox, the Client must be the owner of that Sandbox.
This is the Client Secret of the Client created in instagram.com/developer. If using a Sandbox, the Client must be the owner of that Sandbox.
Click here to generate a new access token (in the form of a JSON string) to authenticate plugin's calls to Instagram.
Requires a valid Client ID and Client Secret to be set, and for the Redirect URIs in the Instagram Client to include {{ siteUrl }}actions/instagramLoader/authentication/authenticate.
Save any other changes to these settings first before generating a token.
The id of the Section used. Automatically populated on plugin install.
The id of the Entry Type used. Automatically populated on plugin install.
The id of the Category Group used. Automatically populated on plugin install.
Comma separated list of user ids for all users whose accounts should be synced. Web services for translating a user's handle to id can be found e.g. http://jelled.com/instagram/lookup-user-id


|
ft_printf
|
This project is part of the official curriculum at School 42.
write
malloc
free
exit
stdarg
for
loops and switch
statements are forbiddenlibft
written in a previous project.**_Standard_**
csp%
conversionsdiouxX
conversions with hh
, h
, l
, ll
flagsf
conversion with flags L
, l
#0-+
flag management (when applicable)*
flag management**_Extra_**
b
conversion to print in binaryprintf
ft_dprintf
ft_vprintf
ft_vdprintf
ft_sprintf
ft_snprintf
ft_vsprintf
ft_vsnprintf
ft_asprintf
ft_vasprintf
ft_printf("{red} Color-print.{eoc} Normal print.")
Run tests with make test
printf(3)
Many of the included tests are borrowed from pft by gavinfielder and other contributors and Moulitest by yyang42 and other contributors. My thanks go to them.
If you have any questions, please contact me on Github.


Quebec has had a long history of popular uprising against so-called “reasonable accommodation”, special permissions and modifications of public cultural symbols to accommodate immigrants and Quebecers with backgrounds other than french and catholic. Most will remember news stories like Montreal’s YMCA ordeal where Hasidim jews ordered the establishment to tint it’s windows to hide the profane bodies of the athletes training there, or he completely ridiculous security breach where anyone in Canada with a face-covering burqa can vote without showing their face for ID verification.
All these events have triggered a certain animosity against immigrants in general, most particularly against muslims and jews, despite the fact that everybody knows that only a select group of senseless individuals are behind all these frivolous complaints. Countless times I’ve heard friends, relatives and coworkers say the now all too familiar “when in rome” line with a tone reminiscent of outright racism and intolerance.
Ultimately, who is at fault? Most blame the Canadian Charter of Rights and Freedoms, which according to some is almost TOO tolerant and permissive. Stop blaming the document, it is in fact ourselves that are at fault. The Charter is something that lays down concepts, and if a conflict arises over the application over one of these concepts, a judge has to deliberate over it. The problem with the current state of things is that these issues rarely even get to court, as we immediately submit as soon as we see somebody waving the charter belligerently.
The latest example of this is the feud between the CBSC (Canadian Broadcast Standards Council) and radio stations over the playback of a song containing alleged gay slur, Dire Straights’ Money for Nothing (Youtube). Maurais Live’s interview with Mr. Ronald Cowen (14/01/2011) from the CBSC revealed that a single (yes, that’s ONE, as in 1) person had brought up a complaint against the song, and that from then on the council had come to the decision that the use of the word “faggot”, judged an inappropriate slur that discriminates homosexuals, disqualified the song for radio airing.
One song, a handful of “faggots”, one complaint in a quarter century, and a song is banned from the airwaves. Again, this is a prime example of how soft we Canadians collectively are whenever somebody pulls the intolerance card. Please note that the CBSC is NOT a governmental organisation but rather an “independent, non-governmental organization created by the Canadian Association of Broadcasters (CAB) to administer standards established by its members, Canada’s private broadcasters.” When faced to a nonsensical complaint like this one, why is it so hard to have a spine and ignore it in the name of reason? Did the CBSC fear potential legal action? From ONE individual?
I’ve always hated radio edits of anything, even though I understood the the chaste minds of youngsters could be so easily corrupted, I think that our persistence in making “harsh language” a big deal is what makes it so attractive to those people who abuse of such things; it’s the same thing with recreative drugs and alcohol… but that’s a whole other story.
It’s about time we stopped being faggots.


How Disney teaches kids to be suspicious
by Mark FrauenfelderIt's important for kids to learn that the world is replete with charlatans, mountebanks, rascals, rogues, hustlers, flim-flammers, tricksters, and con artists.
Disney is doing its part by selling a kit of "1001 Stickers" of famous Disney princesses like Ariel, Jasmine, etc.  Thanks Disney."
Thanks, indeed!  Thanks Disney. from r/assholedesign
Image: r/assholedesign


Graphing
The Graph view displays the paths (call dependencies) between two functions. Graphs are useful for debugging or navigating through complex source code and header files. Using graphs, you can improve your comprehension of the possible traces between two functions.
A graph uses the information model to track all possible paths between two functions. Unlike Call Tree Diagrams, which show specific, immediate paths from a given entity, a graph lets you take a set of functions and determine what, if any, paths exist between them.
This is especially useful when you are trying to comprehend the relations between a specific set of functions. For example, if, between two functions in a debugging session your software behaves inappropriately, you can use a graph to plot all paths the software can take. You might know of only one path, but a graph shows all others.
A graph, in conjunction with transitive closure, provides a comprehensive course between two functions. Impact Analysis can tell you that a change affects an entity, and Closure shows you that a there is a relationship between two functions, but a graph shows every function in the call path between two functions.


Before Change
"model_version": __model_version__,
"training_package_version": __version__
}
model_json = bytes(json.dumps(model), encoding="utf8")
model_path = directory_path / "nlu_engine.json"
with model_path.open(mode="w") as f:
f.write(model_json.decode("utf8"))
if self.fitted:
required_resources = self.config.get_required_resources()
After Change
"model_version": __model_version__,
"training_package_version": __version__
}
model_json = json_string(model)
model_path = directory_path / "nlu_engine.json"
with model_path.open(mode="w") as f:
f.write(model_json)


Map Visualization
Dashboard
SIW005
Leaflet Maps
Geochart
D3 Maps
Dashboard
Geochart
More maps coming soon...
Ready to Leave?
×
Select "Logout" below if you are ready to end your current session.


Created by Timothy Martin / Business Intelligence Manager
NYC 311 is a contact center providing government information and access to non-emergency services.
311 data is a barometer for the City’s public sentiment. It provides an excellent real-time snapshot into the social, political, economic, and environmental issues which are affecting New Yorkers.
Analyzing trends and patterns allows us to better understand the needs of NYC residents, and the issues affecting specific communities. This allows for a more targeted operational response by City Agencies.
311 Service Request data are accessible through the OpenData API https://nycopendata.socrata.com/. Use this content to improve government through research, analysis, and application development.


{% load otree staticfiles %}
There is {{ Constants.endowment }} to split.  Then the rest will go to the Charity.


Still, I'm a total amateur when it comes to global-traveling.
The time I finally started constructing the website, the countries I’ve been are China, Japan, Vietnam, U.S.A.,
Peru, Bolivia, Chile, Belgium, France, and Spain.
And I think it might be a good start to document my stories within my past journeys, as long as those memories.
Within the website, I plan to mainly focusing on my journey in the past, as well as the ones I start in the
future. However, other topics, information technology, for instance, may also come up to your eyes. (Since I’m
now learning & training myself with the skills of data science, that’s highly possible.)
Also do I get myself a Instagram account, with the photos I’ve shot within the travels. Everyone is welcome of
viewing the account, however; during the time I type down the article, the composition within the account are
mainly based on Mandarin Chinese.
And here’s a little bit introduction of myself,
I’m Ricardo, Ricardo S. Chao, while my mandarin name comes up with Chao, Shang-Han. Born in Taipei, Taiwan. I’m
still now spending most of my time studying in my home country, and hopefully, after acquiring my master degree
(I’m now still a master candidate), I could work aboard and travel a lot during the work-time.
I love travel. Within the time I’m still acquiring my bachelor degree, I travel aboard 3-4 times a year, and
had skipped lots of my classes. (hehe) During the time, I’ve been to Vietnam, New York, China, and Japan.
Especially Japan, within the 13 times my travels within the period, I’ve been to the country about 7-8 times,
and making me (kind of) experienced traveler within the region.
And also China, since the little difference within the language and culture between mainland China and Taiwan, it makes me easy to travel
around the region without facing any kind of communicating obstacle.
Well, I think it’s better to stop here before the article begin to grow larger and larger.
As a conclusion, I would like share my passion to travel as long as any other story I’m facing within my daily
life.
And just in case you would like to further contact me,
my e-mail is<EMAIL_ADDRESS>please fell comfortable to
mail me regarding any possible issue, thanks.


5 Things to know about 7.1
Quality audio that's waterproof
Best heapdhones for working
what's hot now in audio


From the newsletter ... |
|
God's Acre - The churchyard at St Mary'sOver the past few years you may have noticed some small areas of the churchyard have been left unmown during the spring and summer. This has been a positive attempt to promote the growth of wild flowers and encourage a greater variety of wildlife within the churchyard area. The existing variety of habitat is very good. Holly trees and Ivy covered tree stumps offer ideal conditions for a range of invertebrates. For example, caterpillars of the Holly Blue butterfly feed on Holly flowers in their spring generation and on the flowers of Ivy during the autumn generation - the only British butterfly whose main foodplant changes through the seasons. Grass areas left uncut have produced a good number of Primroses this year, and we hope that the striking Orange Hawkweed flowers will appear again later in the season in the area under the wall of the old School (now the Cogges Church Centre). Perhaps with continued care and management other wild flowers will appear! So that we continue to enhance this natural beauty of the churchyard and to comply with our Churchyard Regulations (posted in the Church porch) please remove all artificial flowers from the churchyard. Thank you for your assistance in this matter.
Lawrence Bee and Gill Curwood
Cogges Parish | Other articles | St Mary's Church | Churchyard Regulations | Feedback © 2000; Abridged from Cogges Parish monthly newsletter, number 251, May 2000 |


{% extends 'layout.html' %} {% block css %} {% endblock %} {% block body %}
Code-golf is the art of making computer programmes as small as possible. Its name echoes the game of golf in which the aim is to win with as few strokes as possible. In code-golf, the winner is the person whose program fulfills the requirements with the least bytes of source code.
Every 2 weeks we'll give you a challenge — typically consisting of a set of inputs and the rules to transform them into desired outputs (don't worry, we won't make you do GUIs). Then you'll have 2 weeks to come up with a solution in the language of your choice, and to make it as small as possible. You can submit as many times as you, so feel free to experiment. At the end, we'll check that your solution works, and count the number of bytes it takes. We'll then update the overall scoreboard, and the scoreboard for each language.
Undying fame


Guidance
Details of the changes to how Ofsted will inspect early years provision, schools and further education and skills from September 2015.
Ofsted has launched far-reaching changes to the way it inspects early years provision, schools and further education and skills. These changes will come in to effect from September 2015 and include:
From this page you can access the new common inspection framework and supporting handbooks. There is also additional information outlining the key changes including materials from Ofsted’s national launch conferences.
The changes are a result of the consultation ‘Better inspection for all’ and subsequent response .
The new common inspection framework and handbooks for Ofsted inspectors come into effect from September 2015 for the inspection of schools, further education and skills and early years provision:
Read a summary of the changes:
PDF , 206KB , 12 pages
If you use assistive technology (eg a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
This short film summarises the main changes to education inspection from September 2015:
Below are short films from Ofsted’s national directors explaining the key changes for their remit from September 2015.
Sean Harford, Ofsted’s national director for schools, outlines the key changes to the inspection of maintained schools and academies from September 2015.
Lorna Fitzjohn, Ofsted’s national director for further education and skills (FES), outlines the key changes to the inspection of FES providers from September 2015.
Lorna Fitzjohn outlines the key changes to the inspection of FES providers from September 2015
Nick Hudson Ofsted’s national director for early years, outlines the key changes to the inspection of early years settings from September 2015.
Nick Hudson outlines the key changes to the inspection of early years settings from September 2015
Bradley Simmons, Ofsted’s national director for non-association independent schools, outlines the key changes to the inspection of these schools from September 2015.
Bradley Simmons outlines the key changes to the inspection of these schools from September 2015
Throughout June and July 2015 Ofsted held a series of 8 national launch events. These gave education leaders and practitioners an opportunity to learn more about the changes.
Read the keynote speech by Her Majesty’s Chief Inspector, Sir Michael Wilshaw. Sir Michael Wilshaw introduces the changes and sets out how great leadership is at the heart of the reforms.
View slides from briefing sessions on the common inspection framework, schools, early years and further education and skills:
The future of education inspection: understanding the changes ( PDF , 206KB , 12 pages )
Future of education inspection launch event: common inspection framework slides ( PDF , 657KB , 13 pages )
Future of education inspections launch event: schools session slides ( PDF , 768KB , 32 pages )
Future of education inspection launch event: further education and skills session slides ( PDF , 647KB , 31 pages )
Short films have been produced from early years, school and further education and skills leaders involved in pilot inspections to test the new inspection arrangements.
Sarah Leonce is a childminder. Here she talks about her experience of an early years inspection pilot using the common inspection framework.
Headteachers and principals sharing their experience of short inspection pilots in schools.
School leaders talk about their experience of a short inspection pilot
Marion Plant of North Warwickshire and Hinckley College talks about her experience of a full inspection pilot using the common inspection framework.
Andy Wilson of Westminster Kingsway College talks about his experience of a short inspection pilot.
Andy Wilson of Westminster Kingsway College talks about his experience of a short inspection pilot