 A, B matrices sequentially.
|
| Nd4jCpu.float_batchnorm |
Batch normalization implementation.
|
| Nd4jCpu.float_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
dL/dBeta
|
| Nd4jCpu.float_betainc |
This op calculates regularized incomplete beta integral Ix(a, b).
|
| Nd4jCpu.float_biasadd |
This operation is added for compatibility purposes mostly.
|
| Nd4jCpu.float_biasadd_bp | |
| Nd4jCpu.float_bincount |
bincount operation return a vector with element counted.
|
| Nd4jCpu.float_boolean_and | |
| Nd4jCpu.float_boolean_or | |
| Nd4jCpu.float_broadcast_dynamic_shape |
broadcast_dynamic_shape op.
|
| Nd4jCpu.float_broadcastgradientargs | |
| Nd4jCpu.float_cast |
This operation casts elements of input array to specified data type
PLEASE NOTE: This op is disabled atm, and reserved for future releases.
|
| Nd4jCpu.float_choose |
This op takes either 1 argument and 1 scalar
or 1 argument and another comparison array
and runs a pre defined conditional op.
|
| Nd4jCpu.float_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
|
| Nd4jCpu.float_clipbyavgnorm | |
| Nd4jCpu.float_clipbynorm | |
| Nd4jCpu.float_clipbynorm_bp | |
| Nd4jCpu.float_clipbyvalue |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCpu.float_clone_list |
This operation clones given NDArrayList
|
| Nd4jCpu.float_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
|
| Nd4jCpu.float_concat | |
| Nd4jCpu.float_concat_bp | |
| Nd4jCpu.float_Conditional | |
| Nd4jCpu.float_confusion_matrix |
This operation calculate the confusion matrix for a
pair of prediction and label 1-D arrays.
|
| Nd4jCpu.float_conv1d |
1D temporal convolution implementation
Expected input:
x: 3D array
weight: 3D Array
bias: optional vector
Int args:
0: kernel
1: stride
2: padding
|
| Nd4jCpu.float_conv1d_bp | |
| Nd4jCpu.float_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
|
| Nd4jCpu.float_conv2d_bp | |
| Nd4jCpu.float_conv2d_input_bp | |
| Nd4jCpu.float_conv3d |
3D convolution implementation
IntArgs:
0: dilation T
1: dilation W
2: dilation H
4: padding T
5: padding W
6: padding H
|
| Nd4jCpu.float_conv3d_bp | |
| Nd4jCpu.float_conv3dnew | |
| Nd4jCpu.float_conv3dnew_bp | |
| Nd4jCpu.float_cosine_distance_loss |
Implementation of cosine-distance loss function 1.
|
| Nd4jCpu.float_create_list |
This operation creates new empty NDArrayList
|
| Nd4jCpu.float_crelu |
This is Concatenated RELU implementation.
|
| Nd4jCpu.float_crelu_bp | |
| Nd4jCpu.float_cross |
This op calculates cross-product between input arguments
Input arguments
0 - vector or tensor A
1 - vector or tensor B
|
| Nd4jCpu.float_cube |
This is Cube activation function.
|
| Nd4jCpu.float_cube_bp | |
| Nd4jCpu.float_cumprod | |
| Nd4jCpu.float_cumprod_bp | |
| Nd4jCpu.float_cumsum | |
| Nd4jCpu.float_cumsum_bp | |
| Nd4jCpu.float_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
|
| Nd4jCpu.float_deconv2d_bp | |
| Nd4jCpu.float_deconv2d_tf | |
| Nd4jCpu.float_depth_to_space | |
| Nd4jCpu.float_depthwise_conv2d | |
| Nd4jCpu.float_depthwise_conv2d_bp | |
| Nd4jCpu.float_diag |
Returns a diagonal tensor with a given diagonal values.
|
| Nd4jCpu.float_diag_part |
Returns a diagonal tensor with a given diagonal values.
|
| Nd4jCpu.float_dilation2d |
Dilation2D op
Int args:
0: isSameMode
|
| Nd4jCpu.float_divide |
This is one of auto-broadcastable operations.
|
| Nd4jCpu.float_divide_bp | |
| Nd4jCpu.float_dropout |
This op calculates weighted logarithmic loss of input
Input arguments
0 - input tensor
1 - noise_shape - (vector with shape to reduce) - optional
int parameter - seed for random numbers
T parameter - probability (should be between 0 and 1)
return value - a tensor with the same shape as target or input
|
| Nd4jCpu.float_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, ...]
Output arrays:
0: cell outputs for forward RNN [time x batchSize x numUnitsFW] or [batchSize x time x numUnitsFW]
1: cell outputs for backward RNN [time x batchSize x numUnitsBW] or [batchSize x time x numUnitsBW]
2: cell final non-zero output for forward RNN [batchSize x numUnitsFW]
3: cell final non-zero output for backward RNN [batchSize x numUnitsBW]
|
| Nd4jCpu.float_dynamic_partition |
dynamic_partition - partition a input tensor onto num_partitions
accordingly to index array given.
|
| Nd4jCpu.float_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, ...]
Output arrays:
0: cell outputs [time x batchSize x numUnits] or [batchSize x time x numUnits]
1: cell final non-zero output [batchSize x numUnits]
|
| Nd4jCpu.float_dynamic_stitch |
dynamic_stitch - merge partitions from the second param a input tensor
into a single tensor accordingly to index array given.
|
| Nd4jCpu.float_elu |
This op is ELU activation function.
|
| Nd4jCpu.float_elu_bp | |
| Nd4jCpu.float_embedding_lookup |
embedding_lookup - search for submatrices in given matrix and retunts them
accordingly to index array given.
|
| Nd4jCpu.float_eq_scalar |
This is scalar boolean op.
|
| Nd4jCpu.float_equals |
This op takes 2 equally shaped arrays as input, and provides binary matrix as output.
|
| Nd4jCpu.float_expand_dims | |
| Nd4jCpu.float_expose |
This operations exposes given arguments as it's own outputs, but does it only once.
|
| Nd4jCpu.float_extract_image_patches |
extract_image_patches op - Extract patches from images and put them in the "depth" output dimension.
|
| Nd4jCpu.float_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 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
|
| Nd4jCpu.float_fill |
This operation takes shape as first argument, and returns new NDArray filled with specific scalar value.
|
| Nd4jCpu.float_fill_as |
This operation takes input's shape, and returns new NDArray filled with specified value
Expected arguments:
input: N-dimensional array
T args:
0: scalar value, used to fill NDArray
|
| Nd4jCpu.float_firas_sparse |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCpu.float_Floor | |
| Nd4jCpu.float_floordiv |
This is one of auto-broadcastable operations.
|
| Nd4jCpu.float_floordiv_bp | |
| Nd4jCpu.float_floormod |
This is one of auto-broadcastable operations.
|
| Nd4jCpu.float_floormod_bp | |
| Nd4jCpu.float_fullconv3d | |
| Nd4jCpu.float_fullconv3d_bp | |
| Nd4jCpu.float_fullconv3d_grad | |
| Nd4jCpu.float_fused_batch_norm |
This operation performs batch normalization of layer, it is based on following article http://arxiv.org/abs/1502.03167.
|
| Nd4jCpu.float_gather | |
| Nd4jCpu.float_gather_list |
This operation builds NDArray from NDArrayList using indices
Expected arguments:
x: non-empty list
indices: vector with indices for gather operation
|
| Nd4jCpu.float_gather_nd | |
| Nd4jCpu.float_get_seed | |
| Nd4jCpu.float_greater |
This op takes 2 equally shaped arrays as input, and provides binary matrix as output.
|
| Nd4jCpu.float_greater_equal |
This op takes 2 equally shaped arrays as input, and provides binary matrix as output.
|
| Nd4jCpu.float_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
|
| Nd4jCpu.float_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: input-to-hidden weights, [inSize x 3*numUnits]
3: hidden-to-hidden weights, [numUnits x 3*numUnits]
4: biases, [3*numUnits]
Output arrays:
0: current cell output [batchSize x numUnits], that is at current time step t
|
| Nd4jCpu.float_gt_scalar |
This is scalar boolean op.
|
| Nd4jCpu.float_gte_scalar |
This is scalar boolean op.
|
| Nd4jCpu.float_hardsigmoid |
This is HardSigmoid activation function.
|
| Nd4jCpu.float_hardsigmoid_bp | |
| Nd4jCpu.float_hardtanh |
This is HardTanh activation function.
|
| Nd4jCpu.float_hardtanh_bp | |
| Nd4jCpu.float_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.
|
| Nd4jCpu.float_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.
|
| Nd4jCpu.float_identity |
This is Indentity operation.
|
| Nd4jCpu.float_identity_bp | |
| Nd4jCpu.float_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
|
| Nd4jCpu.float_im2col_bp | |
| Nd4jCpu.float_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).
|
| Nd4jCpu.float_invert_permutation | |
| Nd4jCpu.float_is_non_decreasing |
This op takes 1 n-dimensional array as input, and returns true if for every adjacent pair we have x[i] <= x[i+1].
|
| Nd4jCpu.float_is_numeric_tensor |
This op takes 1 n-dimensional array as input, and returns true if input is a numeric array.
|
| Nd4jCpu.float_is_strictly_increasing |
This op takes 1 n-dimensional array as input, and returns true if for every adjacent pair we have x[i] < x[i+1].
|
| Nd4jCpu.float_ismax |
This op produces binary matrix wrt to target dimension.
|
| Nd4jCpu.float_l2_loss |
l2_loss op.
|
| Nd4jCpu.float_less |
This op takes 2 equally shaped arrays as input, and provides binary matrix as output.
|
| Nd4jCpu.float_less_equal |
This op takes 2 equally shaped arrays as input, and provides binary matrix as output.
|
| Nd4jCpu.float_listdiff |
This operation takes 2 arrays: original values, and values to be excluded.
|
| Nd4jCpu.float_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.
|
| Nd4jCpu.float_log_poison_loss |
This op calculates logarithmic loss of poison distributed input
Input arguments
0 - target
1 - input
optional int - boolean value compute_full_loss: 0 (default) or 1 (compute)
|
| Nd4jCpu.float_log_softmax | |
| Nd4jCpu.float_log_softmax_bp | |
| Nd4jCpu.float_Log1p | |
| Nd4jCpu.float_lrelu |
This is Leaky RELU activation function.
|
| Nd4jCpu.float_lrelu_bp | |
| Nd4jCpu.float_lrn |
Local response normalization implementation as TF.
|
| Nd4jCpu.float_lrn_bp |
Local response normalization - backprop variant.
|
| Nd4jCpu.float_lrn_old |
Local response normalization implementation.
|
| Nd4jCpu.float_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!!!
2: initial cell state [batchSize x numUnits], that is at time step = 0
3: input-to-hidden weights, [inSize x 4*numUnits]
4: hidden-to-hidden weights, [numProj x 4*numUnits]
5: diagonal weights for peephole connections [3*numUnits]
6: projection weights [numUnits x numProj]
7: biases, [4*numUnits]
Input integer arguments:
0: if not zero, provide peephole connections
1: if not zero, then projection is performed, if zero then numProj==numUnits is mandatory!
Input float arguments:
0: clipping value for cell state, if it is not equal to zero, then cell state is clipped
1: clipping value for projected cell output, if it is not equal to zero, then projected cell output is clipped
2: the bias added to forget gates in order to reduce the scale of forgetting in the beginning of the training
Output arrays:
0: cell outputs [time x batchSize x numProj], that is per each time step
1: cell states [time x batchSize x numUnits], that is per each time step
|
| Nd4jCpu.float_lstmCell |
Implementation of operation for LSTM cell with peep hole connections:
S.
|
| Nd4jCpu.float_lt_scalar |
This is scalar boolean op.
|
| Nd4jCpu.float_lte_scalar |
This is scalar boolean op.
|
| Nd4jCpu.float_matmul |
This op is general matmum implementation.
|
| Nd4jCpu.float_matrix_determinant |
matrix_determinant op.
|
| Nd4jCpu.float_matrix_diag |
Returns a batched matrix tensor with diagonal values given (as TF.matrix_diag).
|
| Nd4jCpu.float_matrix_diag_part |
Returns a diagonal vector for any submatricies with in a given tensor.
|
| Nd4jCpu.float_matrix_inverse |
matrix_inverse op.
|
| Nd4jCpu.float_matrix_set_diag |
Returns a batched matrix tensor with new batched diagonal values.
|
| Nd4jCpu.float_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
|
| Nd4jCpu.float_maximum |
This is one of auto-broadcastable operations.
|
| Nd4jCpu.float_maximum_bp | |
| Nd4jCpu.float_maxpool2d |
This op implements max pooling for convolution networks.
|
| Nd4jCpu.float_maxpool2d_bp | |
| Nd4jCpu.float_maxpool3d | |
| Nd4jCpu.float_maxpool3d_bp | |
| Nd4jCpu.float_maxpool3dnew | |
| Nd4jCpu.float_maxpool3dnew_bp | |
| Nd4jCpu.float_mean_pairwssqerr_loss |
Implementation of pairwise-errors-squared loss function
Input arrays:
0: predictions - the predicted values, type float.
|
| Nd4jCpu.float_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.
|
| Nd4jCpu.float_mergeadd | |
| Nd4jCpu.float_mergeavg | |
| Nd4jCpu.float_mergemax | |
| Nd4jCpu.float_mergemaxindex | |
| Nd4jCpu.float_meshgrid | |
| Nd4jCpu.float_minimum |
This is one of auto-broadcastable operations.
|
| Nd4jCpu.float_minimum_bp | |
| Nd4jCpu.float_mirror_pad | |
| Nd4jCpu.float_mod | |
| Nd4jCpu.float_mod_bp | |
| Nd4jCpu.float_moments |
moments operation calculate a mean and variation for given NDArray
with reduce a result according to axis array given.
|
| Nd4jCpu.float_multiply |
This is one of auto-broadcastable operations.
|
| Nd4jCpu.float_multiply_bp | |
| Nd4jCpu.float_neq_scalar |
This is scalar boolean op.
|
| Nd4jCpu.float_noop | |
| Nd4jCpu.float_norm |
This operation provides various normalization modes:
0: frobenius
1: euclidean (norm2)
2: norm1
3: norm2
4: inf-norm
5: p-norm
Expected arguments:
input: N-dimensional array
Int args:
0...: axis
T args:
0: norm mode
1: p for p-norm
|
| Nd4jCpu.float_normalize_moments |
normalize_moments operation normalize already calculated mean and variation
accordingly to shift and count.
|
| Nd4jCpu.float_not_equals |
This op takes 2 equally shaped arrays as input, and provides binary matrix as output.
|
| Nd4jCpu.float_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
|
| Nd4jCpu.float_ones_as |
This operation takes input's shape, and returns new NDArray filled with ones
Expected arguments:
input: N-dimensional array
|
| Nd4jCpu.float_order |
This op changes order of given array to specified order.
|
| Nd4jCpu.float_pad | |
| Nd4jCpu.float_parallel_stack | |
| Nd4jCpu.float_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
|
| Nd4jCpu.float_permute |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCpu.float_pick_list |
This operations selects specified indices fron NDArrayList and returns them as NDArray
Expected arguments:
x: non-empty list
indices: optional, vector with indices
Int args:
optional, indices
|
| Nd4jCpu.float_pnormpool2d |
This op implements pnorm pooling for convolution networks.
|
| Nd4jCpu.float_pnormpool2d_bp | |
| Nd4jCpu.float_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)
|
| Nd4jCpu.float_polygamma |
This op calculates polygamma function psi^(n)(x).
|
| Nd4jCpu.float_pooling2d |
Universal pooling op, combines max/avg/pnorm pooling.
|
| Nd4jCpu.float_prelu |
Parametric Rectified Linear Unit
f(x) = alpha * x for x < 0, f(x) = x for x >= 0
|
| Nd4jCpu.float_prelu_bp | |
| Nd4jCpu.float_random_bernoulli | |
| Nd4jCpu.float_random_crop | |
| Nd4jCpu.float_random_exponential | |
| Nd4jCpu.float_random_normal | |
| Nd4jCpu.float_random_shuffle | |
| Nd4jCpu.float_randomuniform | |
| Nd4jCpu.float_range |
This operation generate sequences.
|
| Nd4jCpu.float_rank |
This operation returns rank of input array as scalar value.
|
| Nd4jCpu.float_rationaltanh |
This is RationalTanh activation function.
|
| Nd4jCpu.float_rationaltanh_bp | |
| Nd4jCpu.float_read_list |
This operations selects specified index fron NDArrayList and returns it as NDArray
Expected arguments:
x: non-empty list
indices: optional, scalar with index
Int args:
optional, index
|
| Nd4jCpu.float_realdiv |
This is one of auto-broadcastable operations.
|
| Nd4jCpu.float_realdiv_bp | |
| Nd4jCpu.float_rectifiedtanh |
This is RectifiedTanh activation function.
|
| Nd4jCpu.float_rectifiedtanh_bp | |
| Nd4jCpu.float_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.
|
| Nd4jCpu.float_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
|
| Nd4jCpu.float_reduce_max_bp | |
| Nd4jCpu.float_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
|
| Nd4jCpu.float_reduce_mean_bp | |
| Nd4jCpu.float_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
|
| Nd4jCpu.float_reduce_min_bp | |
| Nd4jCpu.float_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
|
| Nd4jCpu.float_reduce_norm_max_bp | |
| Nd4jCpu.float_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
|
| Nd4jCpu.float_reduce_norm1_bp | |
| Nd4jCpu.float_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
|
| Nd4jCpu.float_reduce_norm2_bp | |
| Nd4jCpu.float_reduce_prod |
reduction_prod - tf.reduction_prod operation
input params:
0 - NDArray
T_ARG param (optional):
0 - keep_dims != 0.
|
| Nd4jCpu.float_reduce_prod_bp | |
| Nd4jCpu.float_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
|
| Nd4jCpu.float_reduce_sqnorm_bp | |
| Nd4jCpu.float_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
|
| Nd4jCpu.float_reduce_stdev_bp | |
| Nd4jCpu.float_reduce_sum |
reduction_sum - tf.reduction_sum operation
input params:
0 - NDArray
T_ARG param (optional):
0 - keep_dims != 0.
|
| Nd4jCpu.float_reduce_sum_bp | |
| Nd4jCpu.float_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
|
| Nd4jCpu.float_reduce_variance_bp | |
| Nd4jCpu.float_relu |
This is RELU activation function implementation
|
| Nd4jCpu.float_relu_bp | |
| Nd4jCpu.float_relu_layer |
relu_layer = relu(x*w + b)
|
| Nd4jCpu.float_relu6 |
This is RELU6 activation function implementation
|
| Nd4jCpu.float_relu6_bp | |
| Nd4jCpu.float_repeat | |
| Nd4jCpu.float_reshape | |
| Nd4jCpu.float_reshapeas | |
| Nd4jCpu.float_Return | |
| Nd4jCpu.float_reverse | |
| Nd4jCpu.float_reverse_bp | |
| Nd4jCpu.float_reverse_sequence | |
| Nd4jCpu.float_reversedivide |
This is one of auto-broadcastable operations.
|
| Nd4jCpu.float_reversedivide_bp | |
| Nd4jCpu.float_reversemod |
This is one of auto-broadcastable operations.
|
| Nd4jCpu.float_reversemod_bp | |
| Nd4jCpu.float_reversesubtract |
This is one of auto-broadcastable operations.
|
| Nd4jCpu.float_reversesubtract_bp | |
| Nd4jCpu.float_rint |
This operation applies element-wise rint (round to integral value) operation
|
| Nd4jCpu.float_roll |
roll - op porting from numpy (https://docs.scipy.org/doc/numpy-1.14.0/reference/generated/numpy.roll.html)
input params:
0 - NDArray
int params:
0 - shift
1 - axe 1
2 - axe 2
...
|
| Nd4jCpu.float_scatter_add |
This operation applies Add operation to specific inputs wrt indices
Expected arguments:
input: array to be updated
indices: array containing indexes for first dimension of input
updates: array containing elements to be interfered with input
|
| Nd4jCpu.float_scatter_div |
This operation applies Divide operation to specific inputs wrt indices
Expected arguments:
input: array to be updated
indices: array containing indexes for first dimension of input
updates: array containing elements to be interfered with input
|
| Nd4jCpu.float_scatter_list |
This operation unpacks given NDArray into specified NDArrayList wrt specified indices
|
| Nd4jCpu.float_scatter_max |
This operation applies Max operation to specific inputs through given indices
Expected arguments:
input: array to be updated
indices: array containing indexes for first dimension of input
updates: array containing elements to be interfered with input
|
| Nd4jCpu.float_scatter_min |
This operation applies Min operation to specific inputs through given indices
Expected arguments:
input: array to be updated
indices: array containing indexes for first dimension of input
updates: array containing elements to be interfered with input
|
| Nd4jCpu.float_scatter_mul |
This operation applies Multiply operation to specific inputs wrt indices
Expected arguments:
input: array to be updated
indices: array containing indexes for first dimension of input
updates: array containing elements to be interfered with input
|
| Nd4jCpu.float_scatter_sub |
This operation applies Subtract operation to specific inputs wrt indices
Expected arguments:
input: array to be updated
indices: array containing indexes for first dimension of input
updates: array containing elements to be interfered with input
|
| Nd4jCpu.float_scatter_upd |
This operation applies Assign operation to specific inputs wrt indices
Expected arguments:
input: array to be updated
indices: array containing indexes for first dimension of input
updates: array containing elements to be interfered with input
|
| Nd4jCpu.float_scatter_update | |
| Nd4jCpu.float_sconv2d |
Depthwise convolution2d op:
Expected inputs:
x: 4D array, NCHW format
weightsDepth: 4D array,
weightsPointwise: optional, 4D array
bias: optional, vector
|
| Nd4jCpu.float_sconv2d_bp | |
| Nd4jCpu.float_Scope | |
| Nd4jCpu.float_segment_max |
segment_max op.
|
| Nd4jCpu.float_segment_mean |
segment_mean op.
|
| Nd4jCpu.float_segment_min |
segment_min op.
|
| Nd4jCpu.float_segment_prod |
segment_prod op.
|
| Nd4jCpu.float_segment_sum |
segment_sum op.
|
| Nd4jCpu.float_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.
|
| Nd4jCpu.float_selu |
This is SELU activation function implementation
|
| Nd4jCpu.float_selu_bp | |
| Nd4jCpu.float_sequence_mask |
sequence_mask op.
|
| Nd4jCpu.float_set_seed |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCpu.float_shape_of | |
| Nd4jCpu.float_shapes_of | |
| Nd4jCpu.float_sigm_cross_entropy_loss |
Implementation of sigmoid cross-entropy loss function max(logits, 0.) - logits * labels + log(1.
|
| Nd4jCpu.float_sigmoid |
This is Sigmoid activation function implementation
Math is: 1 / 1 + exp(-x)
|
| Nd4jCpu.float_sigmoid_bp | |
| Nd4jCpu.float_size |
This operation returns length of input array
Expected arguments:
input: N-dimensional array
TODO: make this operation reduction, to allow TAD -> size
|
| Nd4jCpu.float_size_at | |
| Nd4jCpu.float_size_list |
This operations returns scalar, with number of existing arrays within given NDArrayList
Expected arguments:
x: list
|
| Nd4jCpu.float_slice |
This operation extracts a slice from a tensor.
|
| Nd4jCpu.float_slice_bp | |
| Nd4jCpu.float_softmax |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCpu.float_softmax_bp | |
| Nd4jCpu.float_softmax_cross_entropy_loss |
Implementation of softmax cross-entropy loss function max(logits, 0.) - logits * labels + log(1.
|
| Nd4jCpu.float_softmax_cross_entropy_loss_with_logits |
Implementation of softmax cross-entropy loss function max(logits, 0.) - logits * labels + log(1.
|
| Nd4jCpu.float_softplus |
This is Softplus activation function implementation
Math is: log(1 + exp(x))
|
| Nd4jCpu.float_softplus_bp | |
| Nd4jCpu.float_softsign |
This is Softsign activation function implementation
Math is: x / 1 + abs(x)
|
| Nd4jCpu.float_softsign_bp | |
| Nd4jCpu.float_space_to_batch | |
| Nd4jCpu.float_space_to_depth | |
| Nd4jCpu.float_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
|
| Nd4jCpu.float_split_list |
This operation splits given NDArray into chunks, and stores them into given NDArrayList wert sizes
Expected arguments:
list: optional, NDArrayList.
|
| Nd4jCpu.float_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
|
| Nd4jCpu.float_square |
This operation applies element-wise pow(x, 2) to the given input
Expected arguments:
input: N-Dimensional array
|
| Nd4jCpu.float_squaredsubtract |
This is one of auto-broadcastable operations.
|
| Nd4jCpu.float_squaredsubtract_bp | |
| Nd4jCpu.float_squeeze | |
| Nd4jCpu.float_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 × 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]
|
| Nd4jCpu.float_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 × 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]
|
| Nd4jCpu.float_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 × 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]
|
| Nd4jCpu.float_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 × 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]
|
| Nd4jCpu.float_sru_bp_logic |
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 × 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]
|
| Nd4jCpu.float_sru_logic |
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 × 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]
|
| Nd4jCpu.float_sru_old |
Implementation of operations 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 × 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]
|
| Nd4jCpu.float_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 × 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
|
| Nd4jCpu.float_stack |
This operation stacks a list of rank tensors into one rank-(R+1) tensor.
|
| Nd4jCpu.float_stack_list |
This operation concatenates given NDArrayList, and returns NDArray as result
|
| Nd4jCpu.float_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]
|
| Nd4jCpu.float_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]
|
| Nd4jCpu.float_stop_gradient |
This operation is missed due it simplicy.
|
| Nd4jCpu.float_strided_slice |
This operation extracts a strided (optionally) slice from a tensor,
|
| Nd4jCpu.float_strided_slice_bp | |
| Nd4jCpu.float_subtract |
This is one of auto-broadcastable operations.
|
| Nd4jCpu.float_subtract_bp | |
| Nd4jCpu.float_sufficient_statistics |
sufficient_statistics operation return calculated mean and variation with data count.
|
| Nd4jCpu.float_svd |
performs singular value decomposition (SVD) of one 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.
|
| Nd4jCpu.float_Switch | |
| Nd4jCpu.float_tanh |
This is Tanh activation function implementation
|
| Nd4jCpu.float_tanh_bp | |
| Nd4jCpu.float_tear |
This operation splits input NDArray into multiple TADs along given dimensions
Expected arguments:
input: N-dimensional array
Int args:
0..: TAD axis
|
| Nd4jCpu.float_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]...
|
| Nd4jCpu.float_test_output_reshape |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCpu.float_test_scalar | |
| Nd4jCpu.float_testcustom | |
| Nd4jCpu.float_testop2i2o | |
| Nd4jCpu.float_testreduction | |
| Nd4jCpu.float_tf_atan2 |
Special atan2 op impl for TF's args order
\tparam T
|
| Nd4jCpu.float_thresholdedrelu |
Thresholded Rectified Linear Unit
f(x) = x for x > theta, f(x) = 0 otherwise
theta must be >= 0
|
| Nd4jCpu.float_thresholdedrelu_bp | |
| Nd4jCpu.float_tile | |
| Nd4jCpu.float_tile_bp | |
| Nd4jCpu.float_tile_to_shape |
This op boosts specified input up to specified shape
\tparam T
|
| Nd4jCpu.float_tile_to_shape_bp | |
| Nd4jCpu.float_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.
|
| Nd4jCpu.float_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.
|
| Nd4jCpu.float_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.
|
| Nd4jCpu.float_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.
|
| Nd4jCpu.float_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.
|
| Nd4jCpu.float_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.
|
| Nd4jCpu.float_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.
|
| Nd4jCpu.float_toggle_bits |
This operation toggles individual bits of each element in array
PLEASE NOTE: This operation is possible only on integer datatypes
\tparam T
|
| Nd4jCpu.float_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.
|
| Nd4jCpu.float_trace | |
| Nd4jCpu.float_transpose | |
| Nd4jCpu.float_tri | |
| Nd4jCpu.float_triu | |
| Nd4jCpu.float_triu_bp | |
| Nd4jCpu.float_truncatediv |
\tparam T
|
| Nd4jCpu.float_unique |
This operation returns unique elements from input array as vector, and their original indices in input array
Expected input:
input: N-dimensional array
|
| Nd4jCpu.float_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
|
| Nd4jCpu.float_unstack |
This op does the same as tear, just uses different input format:
\tparam T
|
| Nd4jCpu.float_unstack_list |
This operation unstacks given NDArray into NDArrayList
|
| Nd4jCpu.float_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
|
| Nd4jCpu.float_upsampling2d_bp | |
| Nd4jCpu.float_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
|
| Nd4jCpu.float_upsampling3d_bp | |
| Nd4jCpu.float_weighted_cross_entropy_with_logits |
This op calculates weighted logarithmic loss of input
Input arguments
0 - target
1 - input
2 - weights (scalar or vector with same as last dimension)
return value - a tensor with the same shape as target or input
|
| Nd4jCpu.float_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.
|
| Nd4jCpu.float_where_np | |
| Nd4jCpu.float_While | |
| Nd4jCpu.float_write_list |
This operations puts given NDArray into (optionally) given NDArrayList.
|
| Nd4jCpu.float_xw_plus_b |
xw_plus_b op.
|
| Nd4jCpu.float_zero_fraction |
zero_fraction op.
|
| Nd4jCpu.float_zeros_as |
This operation takes input's shape, and returns new NDArray filled with zeros
Expected arguments:
input: N-dimensional array
|
| Nd4jCpu.float_zeta |
This op calculates Hurwitz zeta function zeta(x, q) = sum_{n=0}^{inf} (q + n)^{-x}
Implementation is based on Euler-Maclaurin summation formula
Input arrays:
x: define power {-x}, must be > 1, type float.
|
| Nd4jCpu.FloatBooleanOp |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCpu.FloatBroadcastableOp |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCpu.FloatContext |
This class defines input desired for any given node/operation within graph
|
| Nd4jCpu.FloatContextPrototype |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCpu.FloatDeclarableCustomOp |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCpu.FloatDeclarableListOp |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCpu.FloatDeclarableOp |
This class is the basic building block of Graph Operations.
|
| Nd4jCpu.FloatDeclarableReductionOp |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCpu.FloatGraphState |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCpu.FloatLogicOp |
Logic ops are unique snowflakes in any Graph.
|
| Nd4jCpu.FloatNDArray | |
| Nd4jCpu.FloatNDArrayList |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCpu.FloatNDArrayVector | |
| Nd4jCpu.FloatNDArrayVector.Iterator | |
| Nd4jCpu.FloatOpArgsHolder |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCpu.FloatResultSet |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCpu.FloatStash | |
| Nd4jCpu.FloatVariable |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCpu.FloatVariableSpace |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCpu.FloatVariablesSet |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCpu.FlowPath |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCpu.GraphProfile |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCpu.half_absolute_difference_loss | |
| Nd4jCpu.half_add | |
| Nd4jCpu.half_add_bp | |
| Nd4jCpu.half_adjust_hue | |
| Nd4jCpu.half_adjust_saturation | |
| Nd4jCpu.half_apply_sgd | |
| Nd4jCpu.half_argmax | |
| Nd4jCpu.half_argmin | |
| Nd4jCpu.half_assign | |
| Nd4jCpu.half_assign_bp | |
| Nd4jCpu.half_avgpool2d | |
| Nd4jCpu.half_avgpool2d_bp | |
| Nd4jCpu.half_avgpool3d | |
| Nd4jCpu.half_avgpool3d_bp | |
| Nd4jCpu.half_avgpool3dnew | |
| Nd4jCpu.half_avgpool3dnew_bp | |
| Nd4jCpu.half_axpy | |
| Nd4jCpu.half_batch_to_space | |
| Nd4jCpu.half_batched_gemm | |
| Nd4jCpu.half_batchnorm | |
| Nd4jCpu.half_batchnorm_bp | |
| Nd4jCpu.half_betainc | |
| Nd4jCpu.half_biasadd | |
| Nd4jCpu.half_biasadd_bp | |
| Nd4jCpu.half_bincount | |
| Nd4jCpu.half_boolean_and | |
| Nd4jCpu.half_boolean_or | |
| Nd4jCpu.half_broadcast_dynamic_shape | |
| Nd4jCpu.half_broadcastgradientargs | |
| Nd4jCpu.half_cast | |
| Nd4jCpu.half_choose | |
| Nd4jCpu.half_clip_by_global_norm | |
| Nd4jCpu.half_clipbyavgnorm | |
| Nd4jCpu.half_clipbynorm | |
| Nd4jCpu.half_clipbynorm_bp | |
| Nd4jCpu.half_clipbyvalue | |
| Nd4jCpu.half_clone_list | |
| Nd4jCpu.half_col2im | |
| Nd4jCpu.half_concat | |
| Nd4jCpu.half_concat_bp | |
| Nd4jCpu.half_Conditional | |
| Nd4jCpu.half_confusion_matrix | |
| Nd4jCpu.half_conv1d | |
| Nd4jCpu.half_conv1d_bp | |
| Nd4jCpu.half_conv2d | |
| Nd4jCpu.half_conv2d_bp | |
| Nd4jCpu.half_conv2d_input_bp | |
| Nd4jCpu.half_conv3d | |
| Nd4jCpu.half_conv3d_bp | |
| Nd4jCpu.half_conv3dnew | |
| Nd4jCpu.half_conv3dnew_bp | |
| Nd4jCpu.half_cosine_distance_loss | |
| Nd4jCpu.half_create_list | |
| Nd4jCpu.half_crelu | |
| Nd4jCpu.half_crelu_bp | |
| Nd4jCpu.half_cross | |
| Nd4jCpu.half_cube | |
| Nd4jCpu.half_cube_bp | |
| Nd4jCpu.half_cumprod | |
| Nd4jCpu.half_cumprod_bp | |
| Nd4jCpu.half_cumsum | |
| Nd4jCpu.half_cumsum_bp | |
| Nd4jCpu.half_deconv2d | |
| Nd4jCpu.half_deconv2d_bp | |
| Nd4jCpu.half_deconv2d_tf | |
| Nd4jCpu.half_depth_to_space | |
| Nd4jCpu.half_depthwise_conv2d | |
| Nd4jCpu.half_depthwise_conv2d_bp | |
| Nd4jCpu.half_diag | |
| Nd4jCpu.half_diag_part | |
| Nd4jCpu.half_dilation2d | |
| Nd4jCpu.half_divide | |
| Nd4jCpu.half_divide_bp | |
| Nd4jCpu.half_dropout | |
| Nd4jCpu.half_dynamic_bidirectional_rnn | |
| Nd4jCpu.half_dynamic_partition | |
| Nd4jCpu.half_dynamic_rnn | |
| Nd4jCpu.half_dynamic_stitch | |
| Nd4jCpu.half_elu | |
| Nd4jCpu.half_elu_bp | |
| Nd4jCpu.half_embedding_lookup | |
| Nd4jCpu.half_eq_scalar | |
| Nd4jCpu.half_equals | |
| Nd4jCpu.half_expand_dims | |
| Nd4jCpu.half_expose | |
| Nd4jCpu.half_extract_image_patches | |
| Nd4jCpu.half_eye | |
| Nd4jCpu.half_fill | |
| Nd4jCpu.half_fill_as | |
| Nd4jCpu.half_firas_sparse | |
| Nd4jCpu.half_Floor | |
| Nd4jCpu.half_floordiv | |
| Nd4jCpu.half_floordiv_bp | |
| Nd4jCpu.half_floormod | |
| Nd4jCpu.half_floormod_bp | |
| Nd4jCpu.half_fullconv3d | |
| Nd4jCpu.half_fullconv3d_bp | |
| Nd4jCpu.half_fullconv3d_grad | |
| Nd4jCpu.half_fused_batch_norm | |
| Nd4jCpu.half_gather | |
| Nd4jCpu.half_gather_list | |
| Nd4jCpu.half_gather_nd | |
| Nd4jCpu.half_get_seed | |
| Nd4jCpu.half_greater | |
| Nd4jCpu.half_greater_equal | |
| Nd4jCpu.half_gru | |
| Nd4jCpu.half_gruCell | |
| Nd4jCpu.half_gt_scalar | |
| Nd4jCpu.half_gte_scalar | |
| Nd4jCpu.half_hardsigmoid | |
| Nd4jCpu.half_hardsigmoid_bp | |
| Nd4jCpu.half_hardtanh | |
| Nd4jCpu.half_hardtanh_bp | |
| Nd4jCpu.half_hinge_loss | |
| Nd4jCpu.half_huber_loss | |
| Nd4jCpu.half_identity | |
| Nd4jCpu.half_identity_bp | |
| Nd4jCpu.half_im2col | |
| Nd4jCpu.half_im2col_bp | |
| Nd4jCpu.half_in_top_k | |
| Nd4jCpu.half_invert_permutation | |
| Nd4jCpu.half_is_non_decreasing | |
| Nd4jCpu.half_is_numeric_tensor | |
| Nd4jCpu.half_is_strictly_increasing | |
| Nd4jCpu.half_ismax | |
| Nd4jCpu.half_l2_loss | |
| Nd4jCpu.half_less | |
| Nd4jCpu.half_less_equal | |
| Nd4jCpu.half_listdiff | |
| Nd4jCpu.half_log_loss | |
| Nd4jCpu.half_log_poison_loss | |
| Nd4jCpu.half_log_softmax | |
| Nd4jCpu.half_log_softmax_bp | |
| Nd4jCpu.half_Log1p | |
| Nd4jCpu.half_lrelu | |
| Nd4jCpu.half_lrelu_bp | |
| Nd4jCpu.half_lrn | |
| Nd4jCpu.half_lrn_bp | |
| Nd4jCpu.half_lrn_old | |
| Nd4jCpu.half_lstm | |
| Nd4jCpu.half_lstmCell | |
| Nd4jCpu.half_lt_scalar | |
| Nd4jCpu.half_lte_scalar | |
| Nd4jCpu.half_matmul | |
| Nd4jCpu.half_matrix_determinant | |
| Nd4jCpu.half_matrix_diag | |
| Nd4jCpu.half_matrix_diag_part | |
| Nd4jCpu.half_matrix_inverse | |
| Nd4jCpu.half_matrix_set_diag | |
| Nd4jCpu.half_max_pool_with_argmax | |
| Nd4jCpu.half_maximum | |
| Nd4jCpu.half_maximum_bp | |
| Nd4jCpu.half_maxpool2d | |
| Nd4jCpu.half_maxpool2d_bp | |
| Nd4jCpu.half_maxpool3d | |
| Nd4jCpu.half_maxpool3d_bp | |
| Nd4jCpu.half_maxpool3dnew | |
| Nd4jCpu.half_maxpool3dnew_bp | |
| Nd4jCpu.half_mean_pairwssqerr_loss | |
| Nd4jCpu.half_mean_sqerr_loss | |
| Nd4jCpu.half_mergeadd | |
| Nd4jCpu.half_mergeavg | |
| Nd4jCpu.half_mergemax | |
| Nd4jCpu.half_mergemaxindex | |
| Nd4jCpu.half_meshgrid | |
| Nd4jCpu.half_minimum | |
| Nd4jCpu.half_minimum_bp | |
| Nd4jCpu.half_mirror_pad | |
| Nd4jCpu.half_mod | |
| Nd4jCpu.half_mod_bp | |
| Nd4jCpu.half_moments | |
| Nd4jCpu.half_multiply | |
| Nd4jCpu.half_multiply_bp | |
| Nd4jCpu.half_neq_scalar | |
| Nd4jCpu.half_noop | |
| Nd4jCpu.half_norm | |
| Nd4jCpu.half_normalize_moments | |
| Nd4jCpu.half_not_equals | |
| Nd4jCpu.half_onehot | |
| Nd4jCpu.half_ones_as | |
| Nd4jCpu.half_order | |
| Nd4jCpu.half_pad | |
| Nd4jCpu.half_parallel_stack | |
| Nd4jCpu.half_percentile | |
| Nd4jCpu.half_permute | |
| Nd4jCpu.half_pick_list | |
| Nd4jCpu.half_pnormpool2d | |
| Nd4jCpu.half_pnormpool2d_bp | |
| Nd4jCpu.half_pointwise_conv2d | |
| Nd4jCpu.half_polygamma | |
| Nd4jCpu.half_pooling2d | |
| Nd4jCpu.half_prelu | |
| Nd4jCpu.half_prelu_bp | |
| Nd4jCpu.half_random_bernoulli | |
| Nd4jCpu.half_random_crop | |
| Nd4jCpu.half_random_exponential | |
| Nd4jCpu.half_random_normal | |
| Nd4jCpu.half_random_shuffle | |
| Nd4jCpu.half_randomuniform | |
| Nd4jCpu.half_range | |
| Nd4jCpu.half_rank | |
| Nd4jCpu.half_rationaltanh | |
| Nd4jCpu.half_rationaltanh_bp | |
| Nd4jCpu.half_read_list | |
| Nd4jCpu.half_realdiv | |
| Nd4jCpu.half_realdiv_bp | |
| Nd4jCpu.half_rectifiedtanh | |
| Nd4jCpu.half_rectifiedtanh_bp | |
| Nd4jCpu.half_reduce_dot_bp | |
| Nd4jCpu.half_reduce_max | |
| Nd4jCpu.half_reduce_max_bp | |
| Nd4jCpu.half_reduce_mean | |
| Nd4jCpu.half_reduce_mean_bp | |
| Nd4jCpu.half_reduce_min | |
| Nd4jCpu.half_reduce_min_bp | |
| Nd4jCpu.half_reduce_norm_max | |
| Nd4jCpu.half_reduce_norm_max_bp | |
| Nd4jCpu.half_reduce_norm1 | |
| Nd4jCpu.half_reduce_norm1_bp | |
| Nd4jCpu.half_reduce_norm2 | |
| Nd4jCpu.half_reduce_norm2_bp | |
| Nd4jCpu.half_reduce_prod | |
| Nd4jCpu.half_reduce_prod_bp | |
| Nd4jCpu.half_reduce_sqnorm | |
| Nd4jCpu.half_reduce_sqnorm_bp | |
| Nd4jCpu.half_reduce_stdev | |
| Nd4jCpu.half_reduce_stdev_bp | |
| Nd4jCpu.half_reduce_sum | |
| Nd4jCpu.half_reduce_sum_bp | |
| Nd4jCpu.half_reduce_variance | |
| Nd4jCpu.half_reduce_variance_bp | |
| Nd4jCpu.half_relu | |
| Nd4jCpu.half_relu_bp | |
| Nd4jCpu.half_relu_layer | |
| Nd4jCpu.half_relu6 | |
| Nd4jCpu.half_relu6_bp | |
| Nd4jCpu.half_repeat | |
| Nd4jCpu.half_reshape | |
| Nd4jCpu.half_reshapeas | |
| Nd4jCpu.half_Return | |
| Nd4jCpu.half_reverse | |
| Nd4jCpu.half_reverse_bp | |
| Nd4jCpu.half_reverse_sequence | |
| Nd4jCpu.half_reversedivide | |
| Nd4jCpu.half_reversedivide_bp | |
| Nd4jCpu.half_reversemod | |
| Nd4jCpu.half_reversemod_bp | |
| Nd4jCpu.half_reversesubtract | |
| Nd4jCpu.half_reversesubtract_bp | |
| Nd4jCpu.half_rint | |
| Nd4jCpu.half_roll | |
| Nd4jCpu.half_scatter_add | |
| Nd4jCpu.half_scatter_div | |
| Nd4jCpu.half_scatter_list | |
| Nd4jCpu.half_scatter_max | |
| Nd4jCpu.half_scatter_min | |
| Nd4jCpu.half_scatter_mul | |
| Nd4jCpu.half_scatter_sub | |
| Nd4jCpu.half_scatter_upd | |
| Nd4jCpu.half_scatter_update | |
| Nd4jCpu.half_sconv2d | |
| Nd4jCpu.half_sconv2d_bp | |
| Nd4jCpu.half_Scope | |
| Nd4jCpu.half_segment_max | |
| Nd4jCpu.half_segment_mean | |
| Nd4jCpu.half_segment_min | |
| Nd4jCpu.half_segment_prod | |
| Nd4jCpu.half_segment_sum | |
| Nd4jCpu.half_select | |
| Nd4jCpu.half_selu | |
| Nd4jCpu.half_selu_bp | |
| Nd4jCpu.half_sequence_mask | |
| Nd4jCpu.half_set_seed | |
| Nd4jCpu.half_shape_of | |
| Nd4jCpu.half_shapes_of | |
| Nd4jCpu.half_sigm_cross_entropy_loss | |
| Nd4jCpu.half_sigmoid | |
| Nd4jCpu.half_sigmoid_bp | |
| Nd4jCpu.half_size | |
| Nd4jCpu.half_size_at | |
| Nd4jCpu.half_size_list | |
| Nd4jCpu.half_slice | |
| Nd4jCpu.half_slice_bp | |
| Nd4jCpu.half_softmax | |
| Nd4jCpu.half_softmax_bp | |
| Nd4jCpu.half_softmax_cross_entropy_loss | |
| Nd4jCpu.half_softmax_cross_entropy_loss_with_logits | |
| Nd4jCpu.half_softplus | |
| Nd4jCpu.half_softplus_bp | |
| Nd4jCpu.half_softsign | |
| Nd4jCpu.half_softsign_bp | |
| Nd4jCpu.half_space_to_batch | |
| Nd4jCpu.half_space_to_depth | |
| Nd4jCpu.half_split | |
| Nd4jCpu.half_split_list | |
| Nd4jCpu.half_split_v | |
| Nd4jCpu.half_square | |
| Nd4jCpu.half_squaredsubtract | |
| Nd4jCpu.half_squaredsubtract_bp | |
| Nd4jCpu.half_squeeze | |
| Nd4jCpu.half_sru | |
| Nd4jCpu.half_sru_bi | |
| Nd4jCpu.half_sru_bi_bp | |
| Nd4jCpu.half_sru_bp | |
| Nd4jCpu.half_sru_bp_logic | |
| Nd4jCpu.half_sru_logic | |
| Nd4jCpu.half_sru_old | |
| Nd4jCpu.half_sruCell | |
| Nd4jCpu.half_stack | |
| Nd4jCpu.half_stack_list | |
| Nd4jCpu.half_static_bidirectional_rnn | |
| Nd4jCpu.half_static_rnn | |
| Nd4jCpu.half_stop_gradient | |
| Nd4jCpu.half_strided_slice | |
| Nd4jCpu.half_strided_slice_bp | |
| Nd4jCpu.half_subtract | |
| Nd4jCpu.half_subtract_bp | |
| Nd4jCpu.half_sufficient_statistics | |
| Nd4jCpu.half_svd | |
| Nd4jCpu.half_Switch | |
| Nd4jCpu.half_tanh | |
| Nd4jCpu.half_tanh_bp | |
| Nd4jCpu.half_tear | |
| Nd4jCpu.half_tensormmul | |
| Nd4jCpu.half_test_output_reshape | |
| Nd4jCpu.half_test_scalar | |
| Nd4jCpu.half_testcustom | |
| Nd4jCpu.half_testop2i2o | |
| Nd4jCpu.half_testreduction | |
| Nd4jCpu.half_tf_atan2 | |
| Nd4jCpu.half_thresholdedrelu | |
| Nd4jCpu.half_thresholdedrelu_bp | |
| Nd4jCpu.half_tile | |
| Nd4jCpu.half_tile_bp | |
| Nd4jCpu.half_tile_to_shape | |
| Nd4jCpu.half_tile_to_shape_bp | |
| Nd4jCpu.half_to_double | |
| Nd4jCpu.half_to_float16 | |
| Nd4jCpu.half_to_float32 | |
| Nd4jCpu.half_to_int32 | |
| Nd4jCpu.half_to_int64 | |
| Nd4jCpu.half_to_uint32 | |
| Nd4jCpu.half_to_uint64 | |
| Nd4jCpu.half_toggle_bits | |
| Nd4jCpu.half_top_k | |
| Nd4jCpu.half_trace | |
| Nd4jCpu.half_transpose | |
| Nd4jCpu.half_tri | |
| Nd4jCpu.half_triu | |
| Nd4jCpu.half_triu_bp | |
| Nd4jCpu.half_truncatediv | |
| Nd4jCpu.half_unique | |
| Nd4jCpu.half_unique_with_counts | |
| Nd4jCpu.half_unstack | |
| Nd4jCpu.half_unstack_list | |
| Nd4jCpu.half_upsampling2d | |
| Nd4jCpu.half_upsampling2d_bp | |
| Nd4jCpu.half_upsampling3d | |
| Nd4jCpu.half_upsampling3d_bp | |
| Nd4jCpu.half_weighted_cross_entropy_with_logits | |
| Nd4jCpu.half_Where | |
| Nd4jCpu.half_where_np | |
| Nd4jCpu.half_While | |
| Nd4jCpu.half_write_list | |
| Nd4jCpu.half_xw_plus_b | |
| Nd4jCpu.half_zero_fraction | |
| Nd4jCpu.half_zeros_as | |
| Nd4jCpu.half_zeta | |
| Nd4jCpu.HalfBooleanOp | |
| Nd4jCpu.HalfBroadcastableOp | |
| Nd4jCpu.HalfContext | |
| Nd4jCpu.HalfContextPrototype | |
| Nd4jCpu.HalfDeclarableCustomOp | |
| Nd4jCpu.HalfDeclarableListOp | |
| Nd4jCpu.HalfDeclarableOp | |
| Nd4jCpu.HalfDeclarableReductionOp | |
| Nd4jCpu.HalfGraphState | |
| Nd4jCpu.HalfLogicOp | |
| Nd4jCpu.HalfNDArray | |
| Nd4jCpu.HalfNDArrayList | |
| Nd4jCpu.HalfNDArrayVector | |
| Nd4jCpu.HalfNDArrayVector.Iterator | |
| Nd4jCpu.HalfOpArgsHolder | |
| Nd4jCpu.HalfResultSet | |
| Nd4jCpu.HalfStash | |
| Nd4jCpu.HalfVariable | |
| Nd4jCpu.HalfVariableSpace | |
| Nd4jCpu.HalfVariablesSet | |
| Nd4jCpu.IGenerator | |
| Nd4jCpu.IndicesList |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCpu.Intervals |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCpu.IntIntPair | |
| Nd4jCpu.IntVectorVector | |
| Nd4jCpu.KeyPair |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCpu.LongVectorVector | |
| Nd4jCpu.NativeOps |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCpu.NDIndex |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCpu.NDIndexAll | |
| Nd4jCpu.NDIndexInterval | |
| Nd4jCpu.NDIndexPoint | |
| Nd4jCpu.NodeProfile |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCpu.OpDescriptor |
This class is very basic info holder for ops.
|
| Nd4jCpu.OpRegistrator |
This class provides runtime ops lookup, based on opName or opHash.
|
| Nd4jCpu.Pair |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCpu.RandomBuffer | |
| Nd4jCpu.ResultWrapper |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCpu.ShapeInformation |
Shape information approximating
the information on an ndarray
|
| Nd4jCpu.ShapeList |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCpu.Workspace | |
| Nd4jCpu.Xoroshiro128 | |
| Nd4jCpuPresets | |
| Nd4jCuda | |
| Nd4jCuda._loader |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCuda.ArgumentsList |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCuda.CurrentIndexing |
Indexing information
for bounds checking
|
| Nd4jCuda.DoubleBooleanOp | |
| Nd4jCuda.DoubleBroadcastableOp | |
| Nd4jCuda.DoubleContext | |
| Nd4jCuda.DoubleContextPrototype | |
| Nd4jCuda.DoubleDeclarableCustomOp | |
| Nd4jCuda.DoubleDeclarableListOp | |
| Nd4jCuda.DoubleDeclarableOp | |
| Nd4jCuda.DoubleDeclarableReductionOp | |
| Nd4jCuda.DoubleGraphState | |
| Nd4jCuda.DoubleLogicOp | |
| Nd4jCuda.DoubleNDArray | |
| Nd4jCuda.DoubleNDArrayList | |
| Nd4jCuda.DoubleNDArrayVector | |
| Nd4jCuda.DoubleNDArrayVector.Iterator | |
| Nd4jCuda.DoubleOpArgsHolder | |
| Nd4jCuda.DoubleResultSet | |
| Nd4jCuda.DoubleStash | |
| Nd4jCuda.DoubleVariable | |
| Nd4jCuda.DoubleVariableSpace | |
| Nd4jCuda.DoubleVariablesSet | |
| Nd4jCuda.ExternalWorkspace |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCuda.FloatBooleanOp |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCuda.FloatBroadcastableOp |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCuda.FloatContext |
This class defines input desired for any given node/operation within graph
|
| Nd4jCuda.FloatContextPrototype |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCuda.FloatDeclarableCustomOp |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCuda.FloatDeclarableListOp |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCuda.FloatDeclarableOp |
This class is the basic building block of Graph Operations.
|
| Nd4jCuda.FloatDeclarableReductionOp |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCuda.FloatGraphState |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCuda.FloatLogicOp |
Logic ops are unique snowflakes in any Graph.
|
| Nd4jCuda.FloatNDArray | |
| Nd4jCuda.FloatNDArrayList |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCuda.FloatNDArrayVector | |
| Nd4jCuda.FloatNDArrayVector.Iterator | |
| Nd4jCuda.FloatOpArgsHolder |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCuda.FloatResultSet |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCuda.FloatStash | |
| Nd4jCuda.FloatVariable |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCuda.FloatVariableSpace |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCuda.FloatVariablesSet |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCuda.FlowPath |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCuda.GraphProfile |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCuda.HalfBooleanOp | |
| Nd4jCuda.HalfBroadcastableOp | |
| Nd4jCuda.HalfContext | |
| Nd4jCuda.HalfContextPrototype | |
| Nd4jCuda.HalfDeclarableCustomOp | |
| Nd4jCuda.HalfDeclarableListOp | |
| Nd4jCuda.HalfDeclarableOp | |
| Nd4jCuda.HalfDeclarableReductionOp | |
| Nd4jCuda.HalfGraphState | |
| Nd4jCuda.HalfLogicOp | |
| Nd4jCuda.HalfNDArray | |
| Nd4jCuda.HalfNDArrayList | |
| Nd4jCuda.HalfNDArrayVector | |
| Nd4jCuda.HalfNDArrayVector.Iterator | |
| Nd4jCuda.HalfOpArgsHolder | |
| Nd4jCuda.HalfResultSet | |
| Nd4jCuda.HalfStash | |
| Nd4jCuda.HalfVariable | |
| Nd4jCuda.HalfVariableSpace | |
| Nd4jCuda.HalfVariablesSet | |
| Nd4jCuda.IGenerator | |
| Nd4jCuda.IndicesList |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCuda.Intervals |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCuda.IntIntPair | |
| Nd4jCuda.IntVectorVector | |
| Nd4jCuda.KeyPair |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCuda.LongVectorVector | |
| Nd4jCuda.NativeOps |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCuda.NDIndex |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCuda.NDIndexAll | |
| Nd4jCuda.NDIndexInterval | |
| Nd4jCuda.NDIndexPoint | |
| Nd4jCuda.NodeProfile |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCuda.OpDescriptor |
This class is very basic info holder for ops.
|
| Nd4jCuda.OpRegistrator |
This class provides runtime ops lookup, based on opName or opHash.
|
| Nd4jCuda.Pair |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCuda.RandomBuffer | |
| Nd4jCuda.ResultWrapper |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCuda.ShapeInformation |
Shape information approximating
the information on an ndarray
|
| Nd4jCuda.ShapeList |
Copyright (c) 2015-2018 Skymind, Inc.
|
| Nd4jCuda.Workspace | |
| Nd4jCuda.Xoroshiro128 | |
| Nd4jCudaPresets | |
| ResultWrapperAbstraction | |
| SparseNd4jBlas |


Ukraine boasts record high grain harvest at 74.3 mln tonnes as of Nov 28
By the end of November, farmers threshed 0.3 million tonnes more than forecasted this year.
Ukrainian Minister of Economic Development, Trade and Agriculture Tymofiy Mylovanov says Ukrainian agrarians harvested a record high 74.3 million tonnes of grain as of November 28, which exceeded by 0.3 million tonnes the ministry's forecast for 2019.
"Some 74.3 million tonnes of grain and leguminous crops were harvested from an area of 15 million hectares, or 98% of the target, with an average yield of 4.93 tonnes per hectare," he wrote on Facebook on November 28.
The minister added that an average yield was 4.7 tonnes per hectare in 2018.
As UNIAN reported, the economy ministry earlier projected to harvest 74 million tonnes of gain in 2019, which exceeds a record high 70.1 million tonnes collected in 2018.


Edit actions
-
Actions are listed below. Uncollapse each to reveal the controls. To change names, simply edit the text field and press "update". To Delete an action, press the Delete button and confirm in the dialog box
To reload data from the database, press the Refresh button below
-
Actions
-
Edit
Quick Plot


for this application there is really only one type of user, a standard user; there is also no adminstrative function as all operations are initiated by the client
Install extension
On first launch, generate keys
Sharing your key
- button in extension drop-down to copy longterm identity key to clipboard
- Paste this key somewhere public on the internet
Send a message
All messages are sent to groups, even if it message is for one person
type text in popup
select contact groups below text box
ctrl + e or click button to copy to clipboard [close popup]
paste from clipboard
send to group
Receive a message
All messages are received by the individuals who are part of the group the message was sent to
See a message surrounded with ~~GrdMe~~ ~~!GrdMe~~
Attempt to decrypt with set of keys to see if message meant for user
Export a message to the database
go to menu
click export
get file browser
save in location of your choice
if encrypted save encrypted, if not save not
Stretch Features
add options link in key manager menu
change shorcut command
multikey support


|
|
int | cutpool |
| |
|
int | remotepool |
| |
|
char * | remotehost |
| |
|
unsigned short | remoteport |
| |
|
int | domboss |
| |
|
char * | dombosshost |
| |
|
int | connect |
| |
|
int | segments |
| |
|
int | exactsubtour |
| |
|
int | blockcombs |
| |
|
int | growcombs |
| |
|
int | prclique |
| |
|
int | tighten_lp |
| |
|
int | teething_lp |
| |
|
int | cliquetree_lp |
| |
|
int | tighten_pool |
| |
|
int | decker_lp |
| |
|
int | decker_pool |
| |
|
int | star_lp |
| |
|
int | star_pool |
| |
|
int | handling_lp |
| |
|
int | handling_pool |
| |
|
int | maxchunksize |
| |
|
int | filecuts |
| |
|
char * | filecutname |
| |
|
int | teething_pool |
| |
|
int | fastblossom |
| |
|
int | ghfastblossom |
| |
|
int | exactblossom |
| |
|
int | consecutiveones |
| |
|
int | dominos |
| |
|
int | shrunk_dominos |
| |
|
int | necklace |
| |
|
int | usetighten |
| |
|
int | extra_connect |
| |
|
double | nexttol |
| |
|
double | roundtol |
| |
|
int | fastcuts |
| |
The documentation for this struct was generated from the following file:


Your phone number is too short and must be at least 6 digits
Your phone number is too long and must be less than 11 characters
Enter a valid phone number


MoveMouse x,y,[canvas]
Parameters
x,y - Coordinates to move the mouse to.
canvas (optional) - A canvas gadget handle
Description
Moves the mouse to specified x,y coordinates within the screen or canvas if specified.
Index
Click
here
to view the latest version of this page online


Match Play. 0-0 to 5. Should Red double? If doubled, should White take?
pips Red=131 White=141
(CorrectAnswer= 0/0, ErrorScore= 0)
A classic middle game double and take. Red has the advantage but still has two rear checkers and White has no weakness other than his own rear checker which is threatening to escape with a six.
Red wins 28% gammons (hens the double) but White wins the game 35% of the time. Not doubling is a blunder while dropping is worse than a double blunder.
Getting the doubling decisions correct in positions like this is fundamental to successful match play.
Red wins 28% gammons (hens the double) but White wins the game 35% of the time. Not doubling is a blunder while dropping is worse than a double blunder.
Getting the doubling decisions correct in positions like this is fundamental to successful match play.
Cube analysis 2-ply cubeless equity +0.497 (Money: +0.516) 0.647 0.292 0.004 - 0.353 0.073 0.002 Cubeful equities: 1. Double, take +0.819 2. Double, pass +1.000 (+0.181) 3. No double +0.684 (-0.135) Proper cube action: Double, take


_Fixes directory has already been ingested; leaving it as is.
closed
by Cliff Wulfman at 2020-09-23 13:13:54.leaving as is
closed
by Cliff Wulfman at 2020-09-23 13:14:14.leaving as is.
closed
by Cliff Wulfman at 2020-09-23 13:14:30.leaving as is
closed
by Cliff Wulfman at 2020-09-23 13:14:47.pages were a re-ordering; reordered the originals
added_to_project
by Cliff Wulfman at 2020-09-23 13:53:16.moved_columns_in_project
by Cliff Wulfman at 2020-09-23 15:57:37.renamed
by Cliff Wulfman at 2020-09-23 15:59:17.closed
by Cliff Wulfman at 2020-09-23 16:08:09.moved_columns_in_project
by Cliff Wulfman at 2020-09-23 16:08:24.added_to_project
by Cliff Wulfman at 2020-09-23 13:53:08.moved_columns_in_project
by Cliff Wulfman at 2020-09-23 13:58:26.closed
by Cliff Wulfman at 2020-09-23 16:20:09.swapped order of original files
added_to_project
by Cliff Wulfman at 2020-09-23 13:53:11.moved_columns_in_project
by Cliff Wulfman at 2020-09-23 16:18:23.closed
by Cliff Wulfman at 2020-09-23 16:31:06.moved_columns_in_project
by Cliff Wulfman at 2020-09-23 16:31:20.added_to_project
by Cliff Wulfman at 2020-09-23 13:53:20.moved_columns_in_project
by Cliff Wulfman at 2020-09-23 15:13:13.moved_columns_in_project
by Cliff Wulfman at 2020-09-23 15:57:25.closed
by Cliff Wulfman at 2020-09-23 16:31:32.assigned
by Cliff Wulfman at 2020-09-23 13:15:17.added_to_project
by Cliff Wulfman at 2020-09-23 13:53:36.moved_columns_in_project
by Cliff Wulfman at 2020-09-23 14:12:04.closed
by Cliff Wulfman at 2020-09-23 16:31:48.added_to_project
by Cliff Wulfman at 2020-09-23 13:53:33.moved_columns_in_project
by Cliff Wulfman at 2020-09-23 13:53:59.moved_columns_in_project
by Cliff Wulfman at 2020-09-23 13:54:10.closed
by Cliff Wulfman at 2020-09-23 16:31:57.added_to_project
by Cliff Wulfman at 2020-09-23 13:53:30.moved_columns_in_project
by Cliff Wulfman at 2020-09-23 13:54:19.moved_columns_in_project
by Cliff Wulfman at 2020-09-23 15:13:06.closed
by Cliff Wulfman at 2020-09-23 16:32:01.Fixes contains image msc001b118f080098, which is a blank page; in the original, msc001b118f08_0098 is 2-up pages 176-177 of Das Philosophenbuch, and follows the proper order. This replacement seems, then, to be in error.
The fix replaces the final, blank page.
added_to_project
by Cliff Wulfman at 2020-09-23 13:53:13.moved_columns_in_project
by Cliff Wulfman at 2020-09-23 16:08:35.labeled
by Cliff Wulfman at 2020-09-23 16:20:37.closed
by Cliff Wulfman at 2020-09-23 16:45:28.moved_columns_in_project
by Cliff Wulfman at 2020-09-23 18:51:03.unlabeled
by Cliff Wulfman at 2020-09-23 18:51:11.closed
by Cliff Wulfman at 2020-09-23 18:52:36.Oh, so there are actually 2 errors here that are likely interacting.
The mailer template is trying to pull Wayfinder.for(@resource).resource_charge_list.hold_for(netid: @user.uid).expiration_time.in_time_zone("America/New_York")
. Sometimes the hold_for
comes back nil and sometimes expiration_time
comes back nil.
Perhaps there's an error causing the expiration_time
to be nil and then after a number of retries the hold has expired and then the hold_for
begins to return nil.
@tpendragon suggested it may be trying to send the email before recording the update with the expiration time.
As a first step I'd just change deliver_later
to deliver_now
.
sure i can do that real quick.
renamed
by None at 2020-09-23 15:30:25.labeled
by None at 2020-09-23 15:30:34.labeled
by None at 2020-09-23 18:25:15.mentioned
by Trey Pendragon at 2020-09-23 18:31:00.subscribed
by Trey Pendragon at 2020-09-23 18:31:00.referenced
by None at 2020-09-23 18:52:06.referenced
by None at 2020-09-23 19:37:12.closed
by Trey Pendragon at 2020-09-23 20:18:33.head_ref_force_pushed
by None at 2020-09-23 19:37:12.referenced
by Trey Pendragon at 2020-09-23 20:18:33.merged
by Trey Pendragon at 2020-09-23 20:18:33.closed
by Trey Pendragon at 2020-09-23 20:18:34.head_ref_deleted
by Trey Pendragon at 2020-09-23 20:18:35.review_requested
by Trey Pendragon at 2020-09-23 20:18:50.review_requested
by Trey Pendragon at 2020-09-23 20:18:58.unassigned
by Christina Chortaria at 2020-09-23 14:23:41.assigned
by None at 2020-09-23 19:21:10.renamed
by None at 2020-09-23 19:22:04.unassigned
by None at 2020-09-23 20:29:35.assigned
by None at 2020-09-23 20:32:54.Coverage remained the same at 96.578% when pulling 10ab855ed365171777ec6fd08b838877b0790a92 on request-scsb-in-library into 5a1fce7d021f7fb46ab0e23550db9a187d47178e on main.
head_ref_force_pushed
by None at 2020-09-23 13:03:44.deployed
by Trey Pendragon at 2020-09-23 13:05:41.head_ref_force_pushed
by None at 2020-09-23 13:06:21.deployed
by Trey Pendragon at 2020-09-23 13:36:07.head_ref_force_pushed
by None at 2020-09-23 13:40:38.head_ref_force_pushed
by None at 2020-09-23 18:07:06.deployed
by Trey Pendragon at 2020-09-23 18:08:07.renamed
by None at 2020-09-23 14:36:20.referenced
by Francis Kayiwa at 2020-09-23 14:49:07.merged
by Francis Kayiwa at 2020-09-23 14:49:07.closed
by Francis Kayiwa at 2020-09-23 14:49:07.head_ref_deleted
by Francis Kayiwa at 2020-09-23 14:49:08.I've included httpie in my block list and it works.
kayiwa@PU-F5KSY01XF9VN ~/D/d/p/a/sinai_omeka (issue3_create_omeka)> http https://oar-staging.princeton.edu/
HTTP/1.0 403 Forbidden
Connection: close
Content-Length: 452
Content-Type: text/html
Date: Wed, 23 Sep 2020 16:02:09 GMT
Server: OpenBSD relayd
<!DOCTYPE html>

<title>403 Forbidden</title>

Forbidden

Forbidden

Staging Site URL filtered!

<address>OpenBSD relayd at <IP_ADDRESS> port 443</address>

closed
by Francis Kayiwa at 2020-09-23 16:04:28.ready_for_review
by Francis Kayiwa at 2020-09-23 23:40:51.review_requested
by Francis Kayiwa at 2020-09-23 23:41:22.Kim, would you please ask the curators to provide links to the proper finding-aid components for the following two items:
http://arks.princeton.edu/ark:/88435/cc08hg91z -->supplied by Chloe Pfendler: http://pudl.princeton.edu/objects/cc08hg91z = C0101c000668 http://arks.princeton.edu/ark:/88435/kh04dq988 --> supplied by Chloe Pfendler: http://arks.princeton.edu/ark:/88435/kh04dq988 = C0188c00003
If possible, it would also be useful for them to verify that they have been properly ingested into Figgy.
assigned
by Eliot Jordan at 2020-09-23 19:44:03.closed
by Trey Pendragon at 2020-09-23 19:50:55.assigned
by Eliot Jordan at 2020-09-23 19:45:42.closed
by Trey Pendragon at 2020-09-23 19:50:55.referenced
by Trey Pendragon at 2020-09-23 19:50:55.merged
by Trey Pendragon at 2020-09-23 19:50:55.closed
by Trey Pendragon at 2020-09-23 19:50:56.head_ref_deleted
by Trey Pendragon at 2020-09-23 19:51:02.renamed
by Eliot Jordan at 2020-09-23 21:20:12.assigned
by Eliot Jordan at 2020-09-23 22:02:02.referenced
by Kevin Reiss at 2020-09-22 22:03:11.merged
by Kevin Reiss at 2020-09-22 22:03:11.closed
by Kevin Reiss at 2020-09-22 22:03:11.After some discussion we are thinking that for users who do not show up as "campus authorized" we should print up a flash message when the form loads that states:
You are not currently eligible for on-campus services at the Library. Please consult with your Department if you believe you should have access to these services.
referenced
by Kevin Reiss at 2020-09-23 13:06:23.merged
by Kevin Reiss at 2020-09-23 13:06:23.closed
by Kevin Reiss at 2020-09-23 13:06:23.referenced
by None at 2020-09-23 18:02:39.closed
by Kevin Reiss at 2020-09-23 15:29:27.convert_to_draft
by None at 2020-09-23 15:43:54.head_ref_force_pushed
by None at 2020-09-23 16:46:38.head_ref_force_pushed
by None at 2020-09-23 18:02:39.Fields from the form that are different than current transaction metdata: LoanAuthor LoanTitle LoanPublisher LoanPlace LoanDate LoanEdition
Fields that overlap with current Transaction metadata and should be the same: ItemInfo3 (Volume) ItemInfo4 (Issue) ISSN CallNumber ESPNumber (oclc) AcceptNonEnglish CitedIn NotWantedAfter Notes
Fields that might change based on item: CitedPages (really reason for request [Item's status is missing or lost in the Main Catalog, Princeton owns this title, but it is checked out, Item's status is on order in the Main Catalog]
review_requested
by Axa Mei Liauw at 2020-09-23 13:08:34.review_requested
by Axa Mei Liauw at 2020-09-23 13:08:34.referenced
by Kevin Reiss at 2020-09-23 14:18:09.merged
by Kevin Reiss at 2020-09-23 14:18:09.closed
by Kevin Reiss at 2020-09-23 14:18:09.head_ref_deleted
by Kevin Reiss at 2020-09-23 14:18:14.


--- title: 'Data cleaning music: Nina Simone - Baltimore' date: 2015-04-28 17:03:38 Z layout: post type: post status: publish author: Nathaniel ---


WebORB Enterprise Edition Overview
|
Introduction WebORB Enterprise Edition is the latest addition to the WebORB product family. It includes all the functionality available in Standard and Professional editions plus adds support for Flex Messaging, real-time streaming and data management for Flex clients. By using WebORB Enterprise Edition, your online applications can reach new level of interactivity:
The product provides an implementation of RTMP (real-time messaging protocol) and thus supports client applications using the following Flex/Flash streaming and messaging APIs:
Execution Modes WebORB Enterprise can run inside of an ASP.NET application (requires .NET framework version 2.0 or higher), or can be started in the standalone mode where no web server is required. Alternatively, it is possible to create a Windows service using WebORB server API. When hosted in a ASP.NET application WebORB starts via the Application listener in Global.asax. The file resides in the root directory of the application and is automatically compiled upon initial application request. The server runs on a special port since the messaging protocol requires a dedicated TCP/IP socket and cannot be transported over HTTP. The default port is 2037. To change the port, modify Global.asax and make sure to make the same change in WEB-INF/flex/services-config.xml To run WebORB in the standalone mode, run weborbee.exe in a command prompt window. The executable is located in the root of the weborb's default virtual directory (Inetpub/wwwroot/weborb30). Both hosted and standalone application modes use the same configuration files - weborb.config from the root and WEB-INF/flex/*.xml (used for Flex application configuration). Flex Messaging WebORB automatically connects Flex clients using messaging API (Producer/Consumer) to MSMQ queues. A queue always corresponds to a messaging destination defined in WEB-INF/flex/messaging-config.xml. By default WebORB creates local private MSMQ queues, however destination configuration can instruct the product to create remotely located public queues instead. Flex Producer objects become queue publishers, Flex Consumers are queue subscribers. WebORB functions as an adapter between MSMQ and Flex clients. Since MSMQ is available for any Windows/.NET process, native applications can interact with Flex clients by exchanging messages via MSMQ. Future releases of the product will include examples demonstrating this functionality. Enterprise Applications Flex/Flash clients using NetConnection API connect to an 'Application' residing on the server. For example the following code connects to "SharedObjectsApp":
WebORB Enterprise supports this concept via application folders located inside of the /Applications directory located in the root of the ASP.NET application (hosted mode) or the same folder where weborbee.exe is started from (standalone mode). Both hosted and standalone WebORB scans the Applications folder to locate all deployed applications. An application can have an option configuration file - app.config. Currently application configuration file is used only to configure custom application handler. Application handler is a .NET class containing application logic that can be invoked by Flex/Flash clients using the NetConnection.call API. Additionally application handler can be configured to be a listener for many application live cycle events like application start/stop, client connect/disconnect, etc. Application handler must implement Weborb.Messaging.Api.IScopeHandler or can simply extend Weborb.Messaging.Server.Adapter.ApplicationAdapter (see VideoChat or Stream Recording examples for sample code). |


Please
sign up
for a Fluidinfo account and enter your credentials on the
options page
.
Enter your Fluidinfo account information
Save
Cancel
You're currently logged in as
.
Logout
.


|
Table 1
|
C-H···π intermolecular interactions in PROG-CNA and PROG-DHB ... |
|
Table 2
|
C-H···O/N interactions in PROG-CNA, PROG-DHB, and PROG-DOD. |
|
Table 3
|
Hydrogen bonds and angles in PROG-CNA, PROG-DHB, and PROG-DO ... |
|
Table 4
|
Crystal data and the structure refinement details. |


Before we start:
- Disclaimer: This is not a financial advise, invest at your own risk.
Table Of Contents:
- Introduction
- Managing My Finance
- Stock Portfolio Strategies
- Tax Loss Harvesting
Introduction
I work in finance and after my work I spend atleast couple of hours reading about finance, It’s a passion for me and I keep learning
something new every day. Recently, I decided to start writing about it and get thoughts from other people.
For me it all started with my internship at Aon, when I was done with my internship, my boss gave me a book to read… Rich Dad
, Poor Dad. It was about 6 years ago and in these last few years I have learned so much about how the money works.
In this financial series I will talk about Retirement, Equities, AI in Finance. Don’t be surprised when quote my favs like Chamath
Palihapitiya & Ray Dalio.
Managing My Finance
Step 1: What is money and how economy works?
Why the heck should we care?
I think Ray Dalio can explain this 10x better than I might be able to. Here we go.
Step 2: How I grew up to care?
I graduated from University of Minnesota, Twin Cities with BS in Electrical Engineering and a student loan of $105k+ at an APY of 14%(Plus
all kinds of fees as my loan was through an Indian bank). To put that into perspective, I was paying more $15k every year just in
interest. Luckily, I understood very well that I had to get my sh** together or our house and land that was used as
collateral for mortgage(Yes, even the education loans need to be given with collateral) will be foreclosed by the bank.
I worked hard, saved every penny until it hurts. I was driving a 1997(~20 year old when I bought it) and doing my own oil changes fixing
the fan when by myself when it broke in dead winter and the temperature outside was -30 degrees as I did not have a house or a garage to
do that. Lived on a $20 weekly grocery budget, shared a 2bed apartment with 2 other friends of mine(wonderful people btw). After 3.5
years, I was able to pay the loans completely.  But it felt good and I think it was a good lesson to understand what is a “DEPRECIATING ASSET”.
My friend at work at that time introduced me to a guy named “Dave Ramsey”. I watched a couple of his videos on Youtube and totally fell
in love with his strategy in life: Be a Banker and Not a Borrower! I think his exact quote was: “If you see me at a bank, I am there to
buy it”. Magical, ab-so-f**-lutely life changing.
“Debt is Dumb”: is more of psychological approach rather than a mathematical one.
Fast Forward: My current investment strategies.
Retirement:
Remember the phrase: “Match before Roth, Roth before Traditional”
I match my work 401k match and put the remaining money into Roth IRA using Fidelity. Once the Roth IRA is maxed out, I try to max out
my 401k(so far haven’t been able to do that, tyring none the less).
Individual Brokerage
Apps: Fidelity, Robinhood, M1 Finance(not anymore).

Below strategy of mine is solely based on my trust in American Economy.
- Plan A: Buy SPY, IVV, VOO
- Plan B: When the Market is down about 10%: Use the Margin @ <= 5% APY (no more than 3 months of savings) to invest in SPY.
- Plan C: If the Market is down more than 30%: I go all in with leveraged ETFs(SPXL, SOXL, UPRO, TQQQ etc…) or options. This is a very
high
risk
investment, I never do this with my retirement.
It has worked out very well for me thus far(might change in future as the markets evolve).
- Yahoo Finance
- Simply Safe Dividends
What’s next?
I will go over how to use AI in building Financial Tools & Models in future posts. Stay connected.
comments powered by


First name
Last name
Position
Office
Start date
Salary
First name
Last name
Position
Office
Start date
Salary


This is an important message! You Should Be Swimming!
You should be with the salamanders, not on dry land!There are salamanders waiting for you.Come join them in the water!
They might crown you queen or king!


Monolithic frontend
Low levels of productivity
Unable to release patches
Filipi da Silva Fuchter @ Dígitro Tecnologia
Monolithic frontend
Low levels of productivity
Unable to release patches
Web components are based on existing web standards. Allow you to create new custom, reusable, encapsulated HTML tags to use in web pages.
Can be used with any JavaScript library or framework that works with HTML.
W3C Standards
- HTML Templates
- Shadow DOM
- Custom Elements
- HTML Imports
Describes a method for declaring inert DOM subtrees in HTML and manipulating them to instantiate document fragments with identical contents.
Describes a method of establishing and maintaining functional boundaries between DOM subtrees and how these subtrees interact with each other within a document tree.
This document describes the method for enabling the author to define and use new types of DOM elements in a document.
This document defines a way to include and reuse HTML documents in other HTML documents.
Hello
My first native example!.
- createdCallback() Called after the element is created.
- attachedCallback() Called when the element is attached to the document.
- detachedCallback() Called when the element is detached from the document.
- attributeChangedCallback() Called when one of attributes of the element is changed.
webcomponentsjs
https://www.webcomponents.org/polyfills.
Library for creating web components. It is designed to make it easier and faster to make custom HTML elements.
My first Polymer example!.
Custom Constructor
Event listener setup
Data binding
dom-repeat and dom-if
Released 2017-05-15
Upgrade from 1.X to 2.0.
Polymer elements have been ported to Hybrid mode to be used in both 1.0- and 2.0-based applications.
Shadow DOM and Custom Elements v1.
Environment:
module.exports = {
suites: ["test/index.html"],
plugins: {
local: {
browsers: ["chrome","firefox"]
}
},
//Executar remotamente
webserver: {
port: 2000,
hostname: '<IP_ADDRESS>',
},
activeBrowsers: [
{
url: "http://<IP_ADDRESS>:4444/wd/hub",
browserName: "internet explorer",
platform: "windows",
takesScreenshot: true,
cssSelectorsEnabled: true,
javascriptEnabled: true,
}
]
};
./node_modules/web-component-tester/bin/wct
XVFB
xvfb-run ./node_modules/web-component-tester/bin/wct
Web components Library built by Digitro Tecnologia
http://webcomponents.digitro.com.br.Available only at Dígitro's intranet.
Showcase project
Web components project
Filipi da Silva Fuchter @ Dígitro Tecnologia


JAYROBIN
Software Engineer. Mostly Front-end. I like to build stuff
Projects
2021
LED Picture Frame
A pixelated picture frame with a hidden game of Snake
2020
Jurassic Park in Blender
Recreating an iconic movie scene in Blender
Frontend Eval
A repository of practice Frontend interview exercises
Pathfinding tones
What do pathfinding algorithms
sound
like?
2016
Bomb n Build
Persistent multiplayer Bomberman with a twist built in Flixel and Socket.io
2014
Ruby Elite
Ruby port of Text Elite by Ian Bell
2013
I quit! Must dash!
Single-button platformer for Flash and iOS
Bertie the Butcher
If Nintendo made a game a about a serial killer for the Game Boy
PlayClone
CS50x final project to remotely record Flash game plays
2012
Micro Thief
A Flash heist game in 18x64 pixels
2008
Lone Defender
Defend the British coast against the Luftwaffe, and read newspapers from The Blitz
Linkaball
My first sponsored Flash game about music, bouncing balls, and chaos
2007
Okama Gamesphere
Early 3D Studio Max project that somehow became the definitive
Okama Gamesphere


| The computer will think of a three digit number with unique digits. After you attempt to guess the number, the computer will tell you how many of your digits match and how many are in the right position. Keeping on submitting three digit numbers until you have guessed the computer's number. |
Enter your name and the click on the PLAY button to begin playing Guessnum !
Click here to see those who may have played a perfect game.
Or here to see those who have clearly hacked the game.
You can search for your favorite Guessnum player by entering the player's name below and then clicking on the SEARCH button.
Guessnum is part of the Vicnum project which was developed for educational purposes to demonstrate common web vulnerabilities. For comments please visit the OWASP project page.


public interface IAlgorithm
| Modifier and Type | Method and Description |
|---|---|
List<org.bukkit.util.Vector> |
calculatePath(GlowBlock startPoint,
GlowBlock endPoint,
Map<org.bukkit.Material,Double> materialWeights,
org.bukkit.Material... blockedMaterials)
Thanks to www.redblobgames.com/pathfinding/a-star/implementation.html
|
default Set<org.bukkit.util.Vector> |
getCornerNeighbors(org.bukkit.util.Vector vector)
Used to get the locations that neighbor a vector's corners.
|
default Set<org.bukkit.util.Vector> |
getFaceNeighbors(org.bukkit.util.Vector vector)
Used to get the locations that neighbor a vector's faces.
|
default Map<org.bukkit.util.Vector,Double> |
getNeighbors(org.bukkit.Location location,
Map<org.bukkit.Material,Double> materialWeights,
Set<org.bukkit.Material> blockedMaterials)
Used to get the locations, as vectors, of neighboring blocks.
|
List<org.bukkit.util.Vector> calculatePath(GlowBlock startPoint, GlowBlock endPoint, Map<org.bukkit.Material,Double> materialWeights, org.bukkit.Material... blockedMaterials)
startPoint
- The starting position.endPoint
- The ending position.materialWeights
- A map containing a material
key, with
a cost
as the value.blockedMaterials
- A varargs of materials
that should be
blocked from pathing.Vectors
that make up the path found during calculation.default Map<org.bukkit.util.Vector,Double> getNeighbors(org.bukkit.Location location, Map<org.bukkit.Material,Double> materialWeights, Set<org.bukkit.Material> blockedMaterials)
location
- The location used in the calculation of neighbors.materialWeights
- A map containing a material
key, with
a cost
as the value.blockedMaterials
- A set of materials that should be ignored.default Set<org.bukkit.util.Vector> getFaceNeighbors(org.bukkit.util.Vector vector)
vector
- The vector we're grabbing the face neighbors of.default Set<org.bukkit.util.Vector> getCornerNeighbors(org.bukkit.util.Vector vector)
vector
- The vector we're grabbing the corner neighbors of.Copyright © 2021. All rights reserved.


Bloodfields
by Professor Whyse
on 2016-02-26
by Professor Whyse
on 2016-02-26
Dave, the techie, has created glasses that filter out non-red light. Thus, looking at the snowfields outside, we see fields of red that make us want to vomit. This reminds us that although snow insinuates itself as a symbol of purity and innocence, it is the cause of widespread death: many a family has met tragedy when their breadwinner dies in a snow-related traffic accident on eir way to work.
These “blood-glasses” help us keep our focus, especially when we are feeling discouraged in our academic work: not only will we resist the hypnotic tendency to stare at the mounds of freshly-fallen snow and let our minds go blank, we will turn up our lips in disgust at the masochistic students building bloodmen (who will bleed to death slowly when the sun shines) outside, and aggressively close the window shades to avoid nausea, instead seeking refuge in our books.
When I suggested to Dave that his invention would have been much more useful back in December, he told me that he, too, had been willfully blind to the dangers of snow until his father’s death. Despite the fact that the snow will soon melt, however, all his glasses have sold out, as many students reasoned that they would be cheaper now than at the beginning of next winter, just as The Shop of Forgotten Things marks up the prices of its umbrellas by 10% during rainy days. Dave reports that some of these students have found a secondary use of the glasses for the non-winter months ahead of us.
“Blue light at night is harmful to our circadian rhythms,” Klarissa says, citing a research article on human biology, “so we use the glasses to study late while minimizing the effects on our sleep.”
Dave apologizes for the shortage, and promises that before next winter, he will have manufactured many more such glasses.