Add random jitter to the vector in the range -j ... +j using the default
{@link Random} generator of {@link MathUtils}.

@param j
the j

@return the vec3 d
335694
function(a,b,c){
			if(b === undefined || c === undefined){
				b = c = a;
			}
			this.x += mathUtils.normalizedRandom()*a;
			this.y += mathUtils.normalizedRandom()*b;
			this.z += mathUtils.normalizedRandom()*c;
			return this;
		}
1337830
private void addEdge(int i, int j) {
		if(!nodes.contains(i)){
			nodes.add(i);
			edges.put(i, new HashSet<Integer>());
			size++;
		}else if(!edges.containsKey(i)){
			edges.put(i, new HashSet<Integer>());
		}

		if(!nodes.contains(j)){
			nodes.add(j);
			size++;
		}
		edgesInv.put(j, i);

		if(!edges.get(i).contains(j)){
			edges.get(i).add(j);
		}

	}
1132265
function(n){
        var mult = Math.sqrt(n*n/this.dot(this));
        return new Vec3(this.x*mult, this.y*mult, this.z*mult);
    }
350069
def add_jac(self, m, val, row, col):
        
        assert m in ('Fx', 'Fy', 'Gx', 'Gy', 'Fx0', 'Fy0', 'Gx0', 'Gy0'), \
            'Wrong Jacobian matrix name <{0}>'.format(m)

        if isinstance(val, (int, float)):
            val = val * ones(len(row), 1)

        self._temp[m]['I'] = matrix([self._temp[m]['I'], matrix(row)])
        self._temp[m]['J'] = matrix([self._temp[m]['J'], matrix(col)])
        self._temp[m]['V'] = matrix([self._temp[m]['V'], matrix(val)])
695865
public static <V extends NumberVector> V randomVector(NumberVector.Factory<V> factory, int dim) {
    return randomVector(factory, dim, new Random());
  }
769771
@Override
    public INDArray rand(int[] shape, org.nd4j.linalg.api.rng.Random r) {
        INDArray ret = r.nextDouble(shape);
        return ret;
    }
155880
public Vector3d add(Vector3dc v, Vector3d dest) {
        dest.x = x + v.x();
        dest.y = y + v.y();
        dest.z = z + v.z();
        return dest;
    }
571925
function randomAxis(v) {
    v = v || new Vector3();

    v.x = Math$1.randFloatSpread(2.0);
    v.y = Math$1.randFloatSpread(2.0);
    v.z = Math$1.randFloatSpread(2.0);
    v.normalize();

    return v;
  }
737719
public Vector3i add(int x, int y, int z) {
        return add(x, y, z, thisOrNew());
    }
95660
static Object wrapVec3(float x, float y, float z) {
        ByteBuffer temp = ByteBuffer.allocate(3 * 4);
        temp.putFloat(x);
        temp.putFloat(y);
        temp.putFloat(z);
        temp.flip();
        return s_wrapperProvider.wrapVector3f(temp, 0, 3);
    }
991152
public Vector3i add(int x, int y, int z, Vector3i dest) {
        dest.x = this.x + x;
        dest.y = this.y + y;
        dest.z = this.z + z;
        return dest;
    }
167008
public RandomVariableInterface addRatio(RandomVariableInterface numerator, RandomVariableInterface denominator) {
		// Set time of this random variable to maximum of time with respect to which measurability is known.
		double newTime = Math.max(Math.max(time, numerator.getFiltrationTime()), denominator.getFiltrationTime());

		if(isDeterministic() && numerator.isDeterministic() && denominator.isDeterministic()) {
			double newValueIfNonStochastic = valueIfNonStochastic + (numerator.get(0) / denominator.get(0));
			return new RandomVariableLowMemory(newTime, newValueIfNonStochastic);
		}
		else {
			double[] newRealizations = new double[Math.max(Math.max(size(), numerator.size()), denominator.size())];
			for(int i=0; i<newRealizations.length; i++) {
				newRealizations[i]		 = get(i) + numerator.get(i) / denominator.get(i);
			}
			return new RandomVariableLowMemory(newTime, newRealizations);
		}
	}
898259
public static BasicVector random(int length, Random random) {
        double[] array = new double[length];
        for (int i = 0; i < length; i++) {
            array[i] = random.nextDouble();
        }

        return new BasicVector(array);
    }
1213172
private E[][] createAbar(E[][] array, int i, int j)
    {
        E[][] ret = createSameSize(array);
        int height = ret.length;
        int width = ret[0].length;
        for (int r = 0; r < height; r++)
        {
            for (int s = 0; s < width; s++)
            {
                if ((r != i) && (s != j))
                {
                    E det = determinant(array, r, s, i, j);
                    E oneOverAij = reciprocal(array[i][j]);
                    ret[r][s] = multiply(det, oneOverAij);
                }
                else if ((r != i) && (s == j))
                {
                    E oneOverAij = reciprocal(array[i][j]);
                    ret[r][s] = multiply(array[r][j], oneOverAij);
                }
                else if ((r == i) && (s != j))
                {
                    E oneOverAij = reciprocal(array[i][j]);
                    E negAis = negate(array[i][s]);
                    ret[r][s] = multiply(negAis, oneOverAij);
                }
                else if ((r == i) && (s == j))
                {
                    E oneOverAij = reciprocal(array[i][j]);
                    ret[r][s] = oneOverAij;
                }
                else
                {
                    throw new SecretShareException("Programmer error");
                }
                //System.out.println("h=" + height + " w=" + width +
                // " r=" + r + " s=" + s + " val=" + ret[r][s]);
            }
        }

        return ret;
    }
828422
public static DenseMatrix random(int rows, int columns, Random random) {
        return Basic2DMatrix.random(rows, columns, random);
    }
986698
@Override
	public RandomVariable add(RandomVariable randomVariable) {
		return apply(OperatorType.ADD, new RandomVariable[]{this, randomVariable});
	}
554590
public Sudoku generateRandomCandidate(Random rng)
    {
        // Clone the template as the basis for this grid.
        Sudoku.Cell[][] rows = template.clone();
        for (int i = 0; i < rows.length; i++)
        {
            rows[i] = template[i].clone();
        }

        // Fill-in the non-fixed cells.
        for (int i = 0; i < rows.length; i++)
        {
            List<Integer> rowValues = nonFixedValues.get(i);
            Collections.shuffle(rowValues);
            int index = 0;
            for (int j = 0; j < rows[i].length; j++)
            {
                if (rows[i][j] == null)
                {
                    rows[i][j] = new Sudoku.Cell(rowValues.get(index), false);
                    ++index;
                }
            }
        }
        return new Sudoku(rows);
    }