public class LongArrays extends java.lang.Object
In particular, the ensureCapacity()
, grow()
,
trim()
and setLength()
methods allow to handle
arrays much like array lists. This can be very useful when efficiency (or
syntactic simplicity) reasons make array lists unsuitable.
Note that BinIO
and TextIO
contain several methods make it possible to load and save arrays of primitive types as sequences
of elements in DataInput
format (i.e., not as objects) or as sequences of lines of text.
There are several sorting methods available. The main theme is that of letting you choose the sorting algorithm you prefer (i.e., trading stability of mergesort for no memory allocation in quicksort). Several algorithms provide a parallel version, that will use the number of cores available. Some algorithms also provide an explicit indirect sorting facility, which makes it possible to sort an array using the values in another array as comparator.
All comparison-based algorithm have an implementation based on a type-specific comparator.
As a general rule, sequential radix sort is significantly faster than quicksort or mergesort, in particular on random-looking data. In the parallel case, up to a few cores parallel radix sort is still the fastest, but at some point quicksort exploits parallelism better.
If you are fine with not knowing exactly which algorithm will be run (in particular, not knowing exactly whether a support array will be allocated),
the dual-pivot parallel sorts in Arrays
are about 50% faster than the classical single-pivot implementation used here.
In any case, if sorting time is important I suggest that you benchmark your sorting load with your data distribution and on your architecture.
Arrays
| Modifier and Type | Class and Description |
|---|---|
protected static class |
LongArrays.ForkJoinQuickSort |
protected static class |
LongArrays.ForkJoinQuickSort2 |
protected static class |
LongArrays.ForkJoinQuickSortComp |
protected static class |
LongArrays.ForkJoinQuickSortIndirect |
protected static class |
LongArrays.Segment |
| Modifier and Type | Field and Description |
|---|---|
static long[] |
EMPTY_ARRAY
A static, final, empty array.
|
static Hash.Strategy<long[]> |
HASH_STRATEGY
A type-specific content-based hash strategy for arrays.
|
protected static LongArrays.Segment |
POISON_PILL |
| Modifier and Type | Method and Description |
|---|---|
static int |
binarySearch(long[] a,
int from,
int to,
long key)
Searches a range of the specified array for the specified value using
the binary search algorithm.
|
static int |
binarySearch(long[] a,
int from,
int to,
long key,
LongComparator c)
Searches a range of the specified array for the specified value using
the binary search algorithm and a specified comparator.
|
static int |
binarySearch(long[] a,
long key)
Searches an array for the specified value using
the binary search algorithm.
|
static int |
binarySearch(long[] a,
long key,
LongComparator c)
Searches an array for the specified value using
the binary search algorithm and a specified comparator.
|
static long[] |
copy(long[] array)
Returns a copy of an array.
|
static long[] |
copy(long[] array,
int offset,
int length)
Returns a copy of a portion of an array.
|
static long[] |
ensureCapacity(long[] array,
int length)
Ensures that an array can contain the given number of entries.
|
static long[] |
ensureCapacity(long[] array,
int length,
int preserve)
Ensures that an array can contain the given number of entries, preserving just a part of the array.
|
static void |
ensureFromTo(long[] a,
int from,
int to)
Ensures that a range given by its first (inclusive) and last (exclusive) elements fits an array.
|
static void |
ensureOffsetLength(long[] a,
int offset,
int length)
Ensures that a range given by an offset and a length fits an array.
|
static void |
ensureSameLength(long[] a,
long[] b)
Ensures that two arrays are of the same length.
|
static boolean |
equals(long[] a1,
long[] a2)
Deprecated.
Please use the corresponding
Arrays method, which is intrinsified in recent JVMs. |
static void |
fill(long[] array,
int from,
int to,
long value)
Deprecated.
Please use the corresponding
Arrays method. |
static void |
fill(long[] array,
long value)
Deprecated.
Please use the corresponding
Arrays method. |
static long[] |
grow(long[] array,
int length)
Grows the given array to the maximum between the given length and
the current length multiplied by two, provided that the given
length is larger than the current length.
|
static long[] |
grow(long[] array,
int length,
int preserve)
Grows the given array to the maximum between the given length and
the current length multiplied by two, provided that the given
length is larger than the current length, preserving just a part of the array.
|
static void |
mergeSort(long[] a)
Sorts an array according to the natural ascending order using mergesort.
|
static void |
mergeSort(long[] a,
int from,
int to)
Sorts the specified range of elements according to the natural ascending order using mergesort.
|
static void |
mergeSort(long[] a,
int from,
int to,
long[] supp)
Sorts the specified range of elements according to the natural ascending order using mergesort, using a given pre-filled support array.
|
static void |
mergeSort(long[] a,
int from,
int to,
LongComparator comp)
Sorts the specified range of elements according to the order induced by the specified
comparator using mergesort.
|
static void |
mergeSort(long[] a,
int from,
int to,
LongComparator comp,
long[] supp)
Sorts the specified range of elements according to the order induced by the specified
comparator using mergesort, using a given pre-filled support array.
|
static void |
mergeSort(long[] a,
LongComparator comp)
Sorts an array according to the order induced by the specified
comparator using mergesort.
|
static void |
parallelQuickSort(long[] x)
Sorts an array according to the natural ascending order using a parallel quicksort.
|
static void |
parallelQuickSort(long[] x,
int from,
int to)
Sorts the specified range of elements according to the natural ascending order using a parallel quicksort.
|
static void |
parallelQuickSort(long[] x,
int from,
int to,
LongComparator comp)
Sorts the specified range of elements according to the order induced by the specified
comparator using a parallel quicksort.
|
static void |
parallelQuickSort(long[] x,
long[] y)
Sorts two arrays according to the natural lexicographical
ascending order using a parallel quicksort.
|
static void |
parallelQuickSort(long[] x,
long[] y,
int from,
int to)
Sorts the specified range of elements of two arrays according to the natural lexicographical
ascending order using a parallel quicksort.
|
static void |
parallelQuickSort(long[] x,
LongComparator comp)
Sorts an array according to the order induced by the specified
comparator using a parallel quicksort.
|
static void |
parallelQuickSortIndirect(int[] perm,
long[] x)
Sorts an array according to the natural ascending order using a parallel indirect quicksort.
|
static void |
parallelQuickSortIndirect(int[] perm,
long[] x,
int from,
int to)
Sorts the specified range of elements according to the natural ascending order using a parallel indirect quicksort.
|
static void |
parallelRadixSort(long[] a)
Sorts the specified array using parallel radix sort.
|
static void |
parallelRadixSort(long[] a,
int from,
int to)
Sorts the specified range of an array using parallel radix sort.
|
static void |
parallelRadixSort(long[] a,
long[] b)
Sorts two arrays using a parallel radix sort.
|
static void |
parallelRadixSort(long[] a,
long[] b,
int from,
int to)
Sorts the specified range of elements of two arrays using a parallel radix sort.
|
static void |
parallelRadixSortIndirect(int[] perm,
long[] a,
boolean stable)
Sorts the specified array using parallel indirect radix sort.
|
static void |
parallelRadixSortIndirect(int[] perm,
long[] a,
int from,
int to,
boolean stable)
Sorts the specified range of an array using parallel indirect radix sort.
|
static void |
quickSort(long[] x)
Sorts an array according to the natural ascending order using quicksort.
|
static void |
quickSort(long[] x,
int from,
int to)
Sorts the specified range of elements according to the natural ascending order using quicksort.
|
static void |
quickSort(long[] x,
int from,
int to,
LongComparator comp)
Sorts the specified range of elements according to the order induced by the specified
comparator using quicksort.
|
static void |
quickSort(long[] x,
long[] y)
Sorts two arrays according to the natural lexicographical ascending order using quicksort.
|
static void |
quickSort(long[] x,
long[] y,
int from,
int to)
Sorts the specified range of elements of two arrays according to the natural lexicographical
ascending order using quicksort.
|
static void |
quickSort(long[] x,
LongComparator comp)
Sorts an array according to the order induced by the specified
comparator using quicksort.
|
static void |
quickSortIndirect(int[] perm,
long[] x)
Sorts an array according to the natural ascending order using indirect quicksort.
|
static void |
quickSortIndirect(int[] perm,
long[] x,
int from,
int to)
Sorts the specified range of elements according to the natural ascending order using indirect quicksort.
|
static void |
radixSort(long[] a)
Sorts the specified array using radix sort.
|
static void |
radixSort(long[][] a)
Sorts the specified array of arrays lexicographically using radix sort.
|
static void |
radixSort(long[][] a,
int from,
int to)
Sorts the specified array of arrays lexicographically using radix sort.
|
static void |
radixSort(long[] a,
int from,
int to)
Sorts the specified range of an array using radix sort.
|
static void |
radixSort(long[] a,
long[] b)
Sorts the specified pair of arrays lexicographically using radix sort.
|
static void |
radixSort(long[] a,
long[] b,
int from,
int to)
Sorts the specified range of elements of two arrays using radix sort.
|
static void |
radixSortIndirect(int[] perm,
long[] a,
boolean stable)
Sorts the specified array using indirect radix sort.
|
static void |
radixSortIndirect(int[] perm,
long[] a,
int from,
int to,
boolean stable)
Sorts the specified array using indirect radix sort.
|
static void |
radixSortIndirect(int[] perm,
long[] a,
long[] b,
boolean stable)
Sorts the specified pair of arrays lexicographically using indirect radix sort.
|
static void |
radixSortIndirect(int[] perm,
long[] a,
long[] b,
int from,
int to,
boolean stable)
Sorts the specified pair of arrays lexicographically using indirect radix sort.
|
static long[] |
reverse(long[] a)
Reverses the order of the elements in the specified array.
|
static long[] |
reverse(long[] a,
int from,
int to)
Reverses the order of the elements in the specified array fragment.
|
static long[] |
setLength(long[] array,
int length)
Sets the length of the given array.
|
static long[] |
shuffle(long[] a,
int from,
int to,
java.util.Random random)
Shuffles the specified array fragment using the specified pseudorandom number generator.
|
static long[] |
shuffle(long[] a,
java.util.Random random)
Shuffles the specified array using the specified pseudorandom number generator.
|
static void |
stabilize(int[] perm,
long[] x)
Stabilizes a permutation.
|
static void |
stabilize(int[] perm,
long[] x,
int from,
int to)
Stabilizes a permutation.
|
static void |
swap(long[] x,
int a,
int b)
Swaps two elements of an anrray.
|
static void |
swap(long[] x,
int a,
int b,
int n)
Swaps two sequences of elements of an array.
|
static long[] |
trim(long[] array,
int length)
Trims the given array to the given length.
|
public static final long[] EMPTY_ARRAY
protected static final LongArrays.Segment POISON_PILL
public static final Hash.Strategy<long[]> HASH_STRATEGY
This hash strategy may be used in custom hash collections whenever keys are
arrays, and they must be considered equal by content. This strategy
will handle null
correctly, and it is serializable.
public static long[] ensureCapacity(long[] array, int length)
If you cannot foresee whether this array will need again to be
enlarged, you should probably use grow()
instead.
array
- an array.length
- the new minimum length for this array.array
, if it contains length
entries or more; otherwise,
an array with length
entries whose first array.length
entries are the same as those of array
.public static long[] ensureCapacity(long[] array, int length, int preserve)
array
- an array.length
- the new minimum length for this array.preserve
- the number of elements of the array that must be preserved in case a new allocation is necessary.array
, if it can contain length
entries or more; otherwise,
an array with length
entries whose first preserve
entries are the same as those of array
.public static long[] grow(long[] array, int length)
If you want complete control on the array growth, you
should probably use ensureCapacity()
instead.
array
- an array.length
- the new minimum length for this array.array
, if it can contain length
entries; otherwise, an array with
max(length
,array.length
/φ) entries whose first
array.length
entries are the same as those of array
.public static long[] grow(long[] array, int length, int preserve)
If you want complete control on the array growth, you
should probably use ensureCapacity()
instead.
array
- an array.length
- the new minimum length for this array.preserve
- the number of elements of the array that must be preserved in case a new allocation is necessary.array
, if it can contain length
entries; otherwise, an array with
max(length
,array.length
/φ) entries whose first
preserve
entries are the same as those of array
.public static long[] trim(long[] array, int length)
array
- an array.length
- the new maximum length for the array.array
, if it contains length
entries or less; otherwise, an array with
length
entries whose entries are the same as
the first length
entries of array
.public static long[] setLength(long[] array, int length)
array
- an array.length
- the new length for the array.array
, if it contains exactly length
entries; otherwise, if it contains more than
length
entries, an array with length
entries
whose entries are the same as the first length
entries of
array
; otherwise, an array with length
entries
whose first array.length
entries are the same as those of
array
.public static long[] copy(long[] array, int offset, int length)
array
- an array.offset
- the first element to copy.length
- the number of elements to copy.length
elements of array
starting at offset
.public static long[] copy(long[] array)
array
- an array.array
.@Deprecated public static void fill(long[] array, long value)
Arrays
method.array
- an array.value
- the new value for all elements of the array.@Deprecated public static void fill(long[] array, int from, int to, long value)
Arrays
method.array
- an array.from
- the starting index of the portion to fill (inclusive).to
- the end index of the portion to fill (exclusive).value
- the new value for all elements of the specified portion of the array.@Deprecated public static boolean equals(long[] a1, long[] a2)
Arrays
method, which is intrinsified in recent JVMs.a1
- an array.a2
- another array.public static void ensureFromTo(long[] a, int from, int to)
This method may be used whenever an array range check is needed.
a
- an array.from
- a start index (inclusive).to
- an end index (exclusive).java.lang.IllegalArgumentException
- if from
is greater than to
.java.lang.ArrayIndexOutOfBoundsException
- if from
or to
are greater than the array length or negative.public static void ensureOffsetLength(long[] a, int offset, int length)
This method may be used whenever an array range check is needed.
a
- an array.offset
- a start index.length
- a length (the number of elements in the range).java.lang.IllegalArgumentException
- if length
is negative.java.lang.ArrayIndexOutOfBoundsException
- if offset
is negative or offset
+length
is greater than the array length.public static void ensureSameLength(long[] a, long[] b)
a
- an array.b
- another array.java.lang.IllegalArgumentException
- if the two argument arrays are not of the same length.public static void swap(long[] x, int a, int b)
x
- an array.a
- a position in x
.b
- another position in x
.public static void swap(long[] x, int a, int b, int n)
x
- an array.a
- a position in x
.b
- another position in x
.n
- the number of elements to exchange starting at a
and b
.public static void quickSort(long[] x, int from, int to, LongComparator comp)
The sorting algorithm is a tuned quicksort adapted from Jon L. Bentley and M. Douglas McIlroy, “Engineering a Sort Function”, Software: Practice and Experience, 23(11), pages 1249−1265, 1993.
Note that this implementation does not allocate any object, contrarily to the implementation
used to sort primitive types in Arrays
, which switches to mergesort on large inputs.
x
- the array to be sorted.from
- the index of the first element (inclusive) to be sorted.to
- the index of the last element (exclusive) to be sorted.comp
- the comparator to determine the sorting order.public static void quickSort(long[] x, LongComparator comp)
The sorting algorithm is a tuned quicksort adapted from Jon L. Bentley and M. Douglas McIlroy, “Engineering a Sort Function”, Software: Practice and Experience, 23(11), pages 1249−1265, 1993.
Note that this implementation does not allocate any object, contrarily to the implementation
used to sort primitive types in Arrays
, which switches to mergesort on large inputs.
x
- the array to be sorted.comp
- the comparator to determine the sorting order.public static void parallelQuickSort(long[] x, int from, int to, LongComparator comp)
The sorting algorithm is a tuned quicksort adapted from Jon L. Bentley and M. Douglas McIlroy, “Engineering a Sort Function”, Software: Practice and Experience, 23(11), pages 1249−1265, 1993.
This implementation uses a ForkJoinPool
executor service with
Runtime.availableProcessors()
parallel threads.
x
- the array to be sorted.from
- the index of the first element (inclusive) to be sorted.to
- the index of the last element (exclusive) to be sorted.comp
- the comparator to determine the sorting order.public static void parallelQuickSort(long[] x, LongComparator comp)
The sorting algorithm is a tuned quicksort adapted from Jon L. Bentley and M. Douglas McIlroy, “Engineering a Sort Function”, Software: Practice and Experience, 23(11), pages 1249−1265, 1993.
This implementation uses a ForkJoinPool
executor service with
Runtime.availableProcessors()
parallel threads.
x
- the array to be sorted.comp
- the comparator to determine the sorting order.public static void quickSort(long[] x, int from, int to)
The sorting algorithm is a tuned quicksort adapted from Jon L. Bentley and M. Douglas McIlroy, “Engineering a Sort Function”, Software: Practice and Experience, 23(11), pages 1249−1265, 1993.
Note that this implementation does not allocate any object, contrarily to the implementation
used to sort primitive types in Arrays
, which switches to mergesort on large inputs.
x
- the array to be sorted.from
- the index of the first element (inclusive) to be sorted.to
- the index of the last element (exclusive) to be sorted.public static void quickSort(long[] x)
The sorting algorithm is a tuned quicksort adapted from Jon L. Bentley and M. Douglas McIlroy, “Engineering a Sort Function”, Software: Practice and Experience, 23(11), pages 1249−1265, 1993.
Note that this implementation does not allocate any object, contrarily to the implementation
used to sort primitive types in Arrays
, which switches to mergesort on large inputs.
x
- the array to be sorted.public static void parallelQuickSort(long[] x, int from, int to)
The sorting algorithm is a tuned quicksort adapted from Jon L. Bentley and M. Douglas McIlroy, “Engineering a Sort Function”, Software: Practice and Experience, 23(11), pages 1249−1265, 1993.
This implementation uses a ForkJoinPool
executor service with
Runtime.availableProcessors()
parallel threads.
x
- the array to be sorted.from
- the index of the first element (inclusive) to be sorted.to
- the index of the last element (exclusive) to be sorted.public static void parallelQuickSort(long[] x)
The sorting algorithm is a tuned quicksort adapted from Jon L. Bentley and M. Douglas McIlroy, “Engineering a Sort Function”, Software: Practice and Experience, 23(11), pages 1249−1265, 1993.
This implementation uses a ForkJoinPool
executor service with
Runtime.availableProcessors()
parallel threads.
x
- the array to be sorted.public static void quickSortIndirect(int[] perm, long[] x, int from, int to)
The sorting algorithm is a tuned quicksort adapted from Jon L. Bentley and M. Douglas McIlroy, “Engineering a Sort Function”, Software: Practice and Experience, 23(11), pages 1249−1265, 1993.
This method implement an indirect sort. The elements of perm
(which must
be exactly the numbers in the interval [0..perm.length)
) will be permuted so that
x[perm[i]] ≤ x[perm[i + 1]]
.
Note that this implementation does not allocate any object, contrarily to the implementation
used to sort primitive types in Arrays
, which switches to mergesort on large inputs.
perm
- a permutation array indexing x
.x
- the array to be sorted.from
- the index of the first element (inclusive) to be sorted.to
- the index of the last element (exclusive) to be sorted.public static void quickSortIndirect(int[] perm, long[] x)
The sorting algorithm is a tuned quicksort adapted from Jon L. Bentley and M. Douglas McIlroy, “Engineering a Sort Function”, Software: Practice and Experience, 23(11), pages 1249−1265, 1993.
This method implement an indirect sort. The elements of perm
(which must
be exactly the numbers in the interval [0..perm.length)
) will be permuted so that
x[perm[i]] ≤ x[perm[i + 1]]
.
Note that this implementation does not allocate any object, contrarily to the implementation
used to sort primitive types in Arrays
, which switches to mergesort on large inputs.
perm
- a permutation array indexing x
.x
- the array to be sorted.public static void parallelQuickSortIndirect(int[] perm, long[] x, int from, int to)
The sorting algorithm is a tuned quicksort adapted from Jon L. Bentley and M. Douglas McIlroy, “Engineering a Sort Function”, Software: Practice and Experience, 23(11), pages 1249−1265, 1993.
This method implement an indirect sort. The elements of perm
(which must
be exactly the numbers in the interval [0..perm.length)
) will be permuted so that
x[perm[i]] ≤ x[perm[i + 1]]
.
This implementation uses a ForkJoinPool
executor service with
Runtime.availableProcessors()
parallel threads.
perm
- a permutation array indexing x
.x
- the array to be sorted.from
- the index of the first element (inclusive) to be sorted.to
- the index of the last element (exclusive) to be sorted.public static void parallelQuickSortIndirect(int[] perm, long[] x)
The sorting algorithm is a tuned quicksort adapted from Jon L. Bentley and M. Douglas McIlroy, “Engineering a Sort Function”, Software: Practice and Experience, 23(11), pages 1249−1265, 1993.
This method implement an indirect sort. The elements of perm
(which must
be exactly the numbers in the interval [0..perm.length)
) will be permuted so that
x[perm[i]] ≤ x[perm[i + 1]]
.
This implementation uses a ForkJoinPool
executor service with
Runtime.availableProcessors()
parallel threads.
perm
- a permutation array indexing x
.x
- the array to be sorted.public static void stabilize(int[] perm, long[] x, int from, int to)
This method can be used to stabilize the permutation generated by an indirect sorting, assuming that
initially the permutation array was in ascending order (e.g., the identity, as usually happens). This method
scans the permutation, and for each non-singleton block of elements with the same associated values in x
,
permutes them in ascending order. The resulting permutation corresponds to a stable sort.
Usually combining an unstable indirect sort and this method is more efficient than using a stable sort, as most stable sort algorithms require a support array.
More precisely, assuming that x[perm[i]] ≤ x[perm[i + 1]]
, after
stabilization we will also have that x[perm[i]] = x[perm[i + 1]]
implies
perm[i] ≤ perm[i + 1]
.
perm
- a permutation array indexing x
so that it is sorted.x
- the sorted array to be stabilized.from
- the index of the first element (inclusive) to be stabilized.to
- the index of the last element (exclusive) to be stabilized.public static void stabilize(int[] perm, long[] x)
This method can be used to stabilize the permutation generated by an indirect sorting, assuming that
initially the permutation array was in ascending order (e.g., the identity, as usually happens). This method
scans the permutation, and for each non-singleton block of elements with the same associated values in x
,
permutes them in ascending order. The resulting permutation corresponds to a stable sort.
Usually combining an unstable indirect sort and this method is more efficient than using a stable sort, as most stable sort algorithms require a support array.
More precisely, assuming that x[perm[i]] ≤ x[perm[i + 1]]
, after
stabilization we will also have that x[perm[i]] = x[perm[i + 1]]
implies
perm[i] ≤ perm[i + 1]
.
perm
- a permutation array indexing x
so that it is sorted.x
- the sorted array to be stabilized.public static void quickSort(long[] x, long[] y, int from, int to)
The sorting algorithm is a tuned quicksort adapted from Jon L. Bentley and M. Douglas McIlroy, “Engineering a Sort Function”, Software: Practice and Experience, 23(11), pages 1249−1265, 1993.
This method implements a lexicographical sorting of the arguments. Pairs of
elements in the same position in the two provided arrays will be considered a single key, and
permuted accordingly. In the end, either x[i] < x[i + 1]
or x[i]
== x[i + 1]
and y[i] ≤ y[i + 1]
.
x
- the first array to be sorted.y
- the second array to be sorted.from
- the index of the first element (inclusive) to be sorted.to
- the index of the last element (exclusive) to be sorted.public static void quickSort(long[] x, long[] y)
The sorting algorithm is a tuned quicksort adapted from Jon L. Bentley and M. Douglas McIlroy, “Engineering a Sort Function”, Software: Practice and Experience, 23(11), pages 1249−1265, 1993.
This method implements a lexicographical sorting of the arguments. Pairs of
elements in the same position in the two provided arrays will be considered a single key, and
permuted accordingly. In the end, either x[i] < x[i + 1]
or x[i]
== x[i + 1]
and y[i] ≤ y[i + 1]
.
x
- the first array to be sorted.y
- the second array to be sorted.public static void parallelQuickSort(long[] x, long[] y, int from, int to)
The sorting algorithm is a tuned quicksort adapted from Jon L. Bentley and M. Douglas McIlroy, “Engineering a Sort Function”, Software: Practice and Experience, 23(11), pages 1249−1265, 1993.
This method implements a lexicographical sorting of the arguments. Pairs of
elements in the same position in the two provided arrays will be considered a single key, and
permuted accordingly. In the end, either x[i] < x[i + 1]
or x[i]
== x[i + 1]
and y[i] ≤ y[i + 1]
.
This implementation uses a ForkJoinPool
executor service with
Runtime.availableProcessors()
parallel threads.
x
- the first array to be sorted.y
- the second array to be sorted.from
- the index of the first element (inclusive) to be sorted.to
- the index of the last element (exclusive) to be sorted.public static void parallelQuickSort(long[] x, long[] y)
The sorting algorithm is a tuned quicksort adapted from Jon L. Bentley and M. Douglas McIlroy, “Engineering a Sort Function”, Software: Practice and Experience, 23(11), pages 1249−1265, 1993.
This method implements a lexicographical sorting of the arguments. Pairs of
elements in the same position in the two provided arrays will be considered a single key, and
permuted accordingly. In the end, either x[i] < x[i + 1]
or x[i]
== x[i + 1]
and y[i] ≤ y[i + 1]
.
This implementation uses a ForkJoinPool
executor service with
Runtime.availableProcessors()
parallel threads.
x
- the first array to be sorted.y
- the second array to be sorted.public static void mergeSort(long[] a, int from, int to, long[] supp)
This sort is guaranteed to be stable: equal elements will not be reordered as a result of the sort. Moreover, no support arrays will be allocated.
a
- the array to be sorted.from
- the index of the first element (inclusive) to be sorted.to
- the index of the last element (exclusive) to be sorted.supp
- a support array containing at least to
elements, and whose entries are identical to those
of a
in the specified range.public static void mergeSort(long[] a, int from, int to)
This sort is guaranteed to be stable: equal elements will not be reordered as a result
of the sort. An array as large as a
will be allocated by this method.
a
- the array to be sorted.from
- the index of the first element (inclusive) to be sorted.to
- the index of the last element (exclusive) to be sorted.public static void mergeSort(long[] a)
This sort is guaranteed to be stable: equal elements will not be reordered as a result
of the sort. An array as large as a
will be allocated by this method.
a
- the array to be sorted.public static void mergeSort(long[] a, int from, int to, LongComparator comp, long[] supp)
This sort is guaranteed to be stable: equal elements will not be reordered as a result of the sort. Moreover, no support arrays will be allocated.
a
- the array to be sorted.from
- the index of the first element (inclusive) to be sorted.to
- the index of the last element (exclusive) to be sorted.comp
- the comparator to determine the sorting order.supp
- a support array containing at least to
elements, and whose entries are identical to those
of a
in the specified range.public static void mergeSort(long[] a, int from, int to, LongComparator comp)
This sort is guaranteed to be stable: equal elements will not be reordered as a result
of the sort. An array as large as a
will be allocated by this method.
a
- the array to be sorted.from
- the index of the first element (inclusive) to be sorted.to
- the index of the last element (exclusive) to be sorted.comp
- the comparator to determine the sorting order.public static void mergeSort(long[] a, LongComparator comp)
This sort is guaranteed to be stable: equal elements will not be reordered as a result
of the sort. An array as large as a
will be allocated by this method.
a
- the array to be sorted.comp
- the comparator to determine the sorting order.public static int binarySearch(long[] a, int from, int to, long key)
a
- the array to be searched.from
- the index of the first element (inclusive) to be searched.to
- the index of the last element (exclusive) to be searched.key
- the value to be searched for.(-(insertion point) - 1)
. The insertion
point is defined as the the point at which the value would
be inserted into the array: the index of the first
element greater than the key, or the length of the array, if all
elements in the array are less than the specified key. Note
that this guarantees that the return value will be ≥ 0 if
and only if the key is found.Arrays
public static int binarySearch(long[] a, long key)
a
- the array to be searched.key
- the value to be searched for.(-(insertion point) - 1)
. The insertion
point is defined as the the point at which the value would
be inserted into the array: the index of the first
element greater than the key, or the length of the array, if all
elements in the array are less than the specified key. Note
that this guarantees that the return value will be ≥ 0 if
and only if the key is found.Arrays
public static int binarySearch(long[] a, int from, int to, long key, LongComparator c)
a
- the array to be searched.from
- the index of the first element (inclusive) to be searched.to
- the index of the last element (exclusive) to be searched.key
- the value to be searched for.c
- a comparator.(-(insertion point) - 1)
. The insertion
point is defined as the the point at which the value would
be inserted into the array: the index of the first
element greater than the key, or the length of the array, if all
elements in the array are less than the specified key. Note
that this guarantees that the return value will be ≥ 0 if
and only if the key is found.Arrays
public static int binarySearch(long[] a, long key, LongComparator c)
a
- the array to be searched.key
- the value to be searched for.c
- a comparator.(-(insertion point) - 1)
. The insertion
point is defined as the the point at which the value would
be inserted into the array: the index of the first
element greater than the key, or the length of the array, if all
elements in the array are less than the specified key. Note
that this guarantees that the return value will be ≥ 0 if
and only if the key is found.Arrays
public static void radixSort(long[] a)
The sorting algorithm is a tuned radix sort adapted from Peter M. McIlroy, Keith Bostic and M. Douglas McIlroy, “Engineering radix sort”, Computing Systems, 6(1), pages 5−27 (1993).
This implementation is significantly faster than quicksort already at small sizes (say, more than 10000 elements), but it can only sort in ascending order.
a
- the array to be sorted.public static void radixSort(long[] a, int from, int to)
The sorting algorithm is a tuned radix sort adapted from Peter M. McIlroy, Keith Bostic and M. Douglas McIlroy, “Engineering radix sort”, Computing Systems, 6(1), pages 5−27 (1993).
This implementation is significantly faster than quicksort already at small sizes (say, more than 10000 elements), but it can only sort in ascending order.
a
- the array to be sorted.from
- the index of the first element (inclusive) to be sorted.to
- the index of the last element (exclusive) to be sorted.public static void parallelRadixSort(long[] a, int from, int to)
The sorting algorithm is a tuned radix sort adapted from Peter M. McIlroy, Keith Bostic and M. Douglas McIlroy, “Engineering radix sort”, Computing Systems, 6(1), pages 5−27 (1993).
This implementation uses a pool of Runtime.availableProcessors()
threads.
a
- the array to be sorted.from
- the index of the first element (inclusive) to be sorted.to
- the index of the last element (exclusive) to be sorted.public static void parallelRadixSort(long[] a)
The sorting algorithm is a tuned radix sort adapted from Peter M. McIlroy, Keith Bostic and M. Douglas McIlroy, “Engineering radix sort”, Computing Systems, 6(1), pages 5−27 (1993).
This implementation uses a pool of Runtime.availableProcessors()
threads.
a
- the array to be sorted.public static void radixSortIndirect(int[] perm, long[] a, boolean stable)
The sorting algorithm is a tuned radix sort adapted from Peter M. McIlroy, Keith Bostic and M. Douglas McIlroy, “Engineering radix sort”, Computing Systems, 6(1), pages 5−27 (1993).
This method implement an indirect sort. The elements of perm
(which must
be exactly the numbers in the interval [0..perm.length)
) will be permuted so that
a[perm[i]] ≤ a[perm[i + 1]]
.
This implementation will allocate, in the stable case, a support array as large as perm
(note that the stable
version is slightly faster).
perm
- a permutation array indexing a
.a
- the array to be sorted.stable
- whether the sorting algorithm should be stable.public static void radixSortIndirect(int[] perm, long[] a, int from, int to, boolean stable)
The sorting algorithm is a tuned radix sort adapted from Peter M. McIlroy, Keith Bostic and M. Douglas McIlroy, “Engineering radix sort”, Computing Systems, 6(1), pages 5−27 (1993).
This method implement an indirect sort. The elements of perm
(which must
be exactly the numbers in the interval [0..perm.length)
) will be permuted so that
a[perm[i]] ≤ a[perm[i + 1]]
.
This implementation will allocate, in the stable case, a support array as large as perm
(note that the stable
version is slightly faster).
perm
- a permutation array indexing a
.a
- the array to be sorted.from
- the index of the first element of perm
(inclusive) to be permuted.to
- the index of the last element of perm
(exclusive) to be permuted.stable
- whether the sorting algorithm should be stable.public static void parallelRadixSortIndirect(int[] perm, long[] a, int from, int to, boolean stable)
The sorting algorithm is a tuned radix sort adapted from Peter M. McIlroy, Keith Bostic and M. Douglas McIlroy, “Engineering radix sort”, Computing Systems, 6(1), pages 5−27 (1993).
This method implement an indirect sort. The elements of perm
(which must
be exactly the numbers in the interval [0..perm.length)
) will be permuted so that
a[perm[i]] ≤ a[perm[i + 1]]
.
This implementation uses a pool of Runtime.availableProcessors()
threads.
perm
- a permutation array indexing a
.a
- the array to be sorted.from
- the index of the first element (inclusive) to be sorted.to
- the index of the last element (exclusive) to be sorted.stable
- whether the sorting algorithm should be stable.public static void parallelRadixSortIndirect(int[] perm, long[] a, boolean stable)
The sorting algorithm is a tuned radix sort adapted from Peter M. McIlroy, Keith Bostic and M. Douglas McIlroy, “Engineering radix sort”, Computing Systems, 6(1), pages 5−27 (1993).
This method implement an indirect sort. The elements of perm
(which must
be exactly the numbers in the interval [0..perm.length)
) will be permuted so that
a[perm[i]] ≤ a[perm[i + 1]]
.
This implementation uses a pool of Runtime.availableProcessors()
threads.
perm
- a permutation array indexing a
.a
- the array to be sorted.stable
- whether the sorting algorithm should be stable.public static void radixSort(long[] a, long[] b)
The sorting algorithm is a tuned radix sort adapted from Peter M. McIlroy, Keith Bostic and M. Douglas McIlroy, “Engineering radix sort”, Computing Systems, 6(1), pages 5−27 (1993).
This method implements a lexicographical sorting of the arguments. Pairs of elements
in the same position in the two provided arrays will be considered a single key, and permuted
accordingly. In the end, either a[i] < a[i + 1]
or a[i] == a[i + 1]
and b[i] ≤ b[i + 1]
.
a
- the first array to be sorted.b
- the second array to be sorted.public static void radixSort(long[] a, long[] b, int from, int to)
The sorting algorithm is a tuned radix sort adapted from Peter M. McIlroy, Keith Bostic and M. Douglas McIlroy, “Engineering radix sort”, Computing Systems, 6(1), pages 5−27 (1993).
This method implements a lexicographical sorting of the arguments. Pairs of elements
in the same position in the two provided arrays will be considered a single key, and permuted
accordingly. In the end, either a[i] < a[i + 1]
or a[i] == a[i + 1]
and b[i] ≤ b[i + 1]
.
a
- the first array to be sorted.b
- the second array to be sorted.from
- the index of the first element (inclusive) to be sorted.to
- the index of the last element (exclusive) to be sorted.public static void parallelRadixSort(long[] a, long[] b, int from, int to)
The sorting algorithm is a tuned radix sort adapted from Peter M. McIlroy, Keith Bostic and M. Douglas McIlroy, “Engineering radix sort”, Computing Systems, 6(1), pages 5−27 (1993).
This method implements a lexicographical sorting of the arguments. Pairs of elements
in the same position in the two provided arrays will be considered a single key, and permuted
accordingly. In the end, either a[i] < a[i + 1]
or a[i] == a[i + 1]
and b[i] ≤ b[i + 1]
.
This implementation uses a pool of Runtime.availableProcessors()
threads.
a
- the first array to be sorted.b
- the second array to be sorted.from
- the index of the first element (inclusive) to be sorted.to
- the index of the last element (exclusive) to be sorted.public static void parallelRadixSort(long[] a, long[] b)
The sorting algorithm is a tuned radix sort adapted from Peter M. McIlroy, Keith Bostic and M. Douglas McIlroy, “Engineering radix sort”, Computing Systems, 6(1), pages 5−27 (1993).
This method implements a lexicographical sorting of the arguments. Pairs of elements
in the same position in the two provided arrays will be considered a single key, and permuted
accordingly. In the end, either a[i] < a[i + 1]
or a[i] == a[i + 1]
and b[i] ≤ b[i + 1]
.
This implementation uses a pool of Runtime.availableProcessors()
threads.
a
- the first array to be sorted.b
- the second array to be sorted.public static void radixSortIndirect(int[] perm, long[] a, long[] b, boolean stable)
The sorting algorithm is a tuned radix sort adapted from Peter M. McIlroy, Keith Bostic and M. Douglas McIlroy, “Engineering radix sort”, Computing Systems, 6(1), pages 5−27 (1993).
This method implement an indirect sort. The elements of perm
(which must
be exactly the numbers in the interval [0..perm.length)
) will be permuted so that
a[perm[i]] ≤ a[perm[i + 1]]
.
This implementation will allocate, in the stable case, a further support array as large as perm
(note that the stable
version is slightly faster).
perm
- a permutation array indexing a
.a
- the array to be sorted.b
- the second array to be sorted.stable
- whether the sorting algorithm should be stable.public static void radixSortIndirect(int[] perm, long[] a, long[] b, int from, int to, boolean stable)
The sorting algorithm is a tuned radix sort adapted from Peter M. McIlroy, Keith Bostic and M. Douglas McIlroy, “Engineering radix sort”, Computing Systems, 6(1), pages 5−27 (1993).
This method implement an indirect sort. The elements of perm
(which must
be exactly the numbers in the interval [0..perm.length)
) will be permuted so that
a[perm[i]] ≤ a[perm[i + 1]]
.
This implementation will allocate, in the stable case, a further support array as large as perm
(note that the stable
version is slightly faster).
perm
- a permutation array indexing a
.a
- the array to be sorted.b
- the second array to be sorted.from
- the index of the first element of perm
(inclusive) to be permuted.to
- the index of the last element of perm
(exclusive) to be permuted.stable
- whether the sorting algorithm should be stable.public static void radixSort(long[][] a)
The sorting algorithm is a tuned radix sort adapted from Peter M. McIlroy, Keith Bostic and M. Douglas McIlroy, “Engineering radix sort”, Computing Systems, 6(1), pages 5−27 (1993).
This method implements a lexicographical sorting of the provided arrays. Tuples of elements in the same position will be considered a single key, and permuted accordingly.
a
- an array containing arrays of equal length to be sorted lexicographically in parallel.public static void radixSort(long[][] a, int from, int to)
The sorting algorithm is a tuned radix sort adapted from Peter M. McIlroy, Keith Bostic and M. Douglas McIlroy, “Engineering radix sort”, Computing Systems, 6(1), pages 5−27 (1993).
This method implements a lexicographical sorting of the provided arrays. Tuples of elements in the same position will be considered a single key, and permuted accordingly.
a
- an array containing arrays of equal length to be sorted lexicographically in parallel.from
- the index of the first element (inclusive) to be sorted.to
- the index of the last element (exclusive) to be sorted.public static long[] shuffle(long[] a, int from, int to, java.util.Random random)
a
- the array to be shuffled.from
- the index of the first element (inclusive) to be shuffled.to
- the index of the last element (exclusive) to be shuffled.random
- a pseudorandom number generator (please use a XorShift* generator).a
.public static long[] shuffle(long[] a, java.util.Random random)
a
- the array to be shuffled.random
- a pseudorandom number generator (please use a XorShift* generator).a
.public static long[] reverse(long[] a)
a
- the array to be reversed.a
.public static long[] reverse(long[] a, int from, int to)
a
- the array to be reversed.from
- the index of the first element (inclusive) to be reversed.to
- the index of the last element (exclusive) to be reversed.a
.Copyright © 2019. All rights reserved.


Containers, which allow software and files to be bundled up into neat packages that can be run on different computers and different operating systems, are earning a lot of attention these days.  Docker is the world's most popular containerization platform. This description of it comes from the Docker Web site:
Docker containers wrap a piece of software in a complete filesystem that contains everything needed to run: code, runtime, system tools, system libraries – anything that can be installed on a server. This guarantees that the software will always run the same, regardless of its environment.
Containers are similar to virtual machines (VMs) in that they provide a predictable and isolated environment in which software can run. Because containers are smaller than VMs, they start almost instantly and use less RAM. Moreover, multiple containers running on a single machine share the same operating system kernel. Docker is based on open standards, enabling Docker containers to run on all major Linux distributions as well as Windows Server 2016.
To simplify the use of Docker containers, Azure offers the Azure Container Service (ACS), which hosts Docker containers in the cloud and provides an optimized configuration of popular open-source scheduling and orchestration tools, including DC/OS, Kubernetes, and Docker Swarm. The latter uses native clustering capabilities to turn a group of Docker engines into a single virtual Docker engine using the configuration shown below and is a handy tool for executing CPU-intensive jobs in parallel. In essence, one or more master VMs control a "swarm" of agent VMs created from an Azure Virtual Machine Scale Set. The agent VMs host Docker containers that execute your code.
Docker Swarm configuration in the Azure Container Service
In this lab, you will package a Python app and a set of color images in a Docker container. Then you will run the container in Azure and run the Python app inside it to convert the color images to grayscale. You will get hands-on experience using the Azure Container Service and tunneling in to execute Docker commands and manipulate Docker containers.
In this hands-on lab, you will learn how to:
The following are required to complete this hands-on lab:
To install the Docker client for Windows, open https://get.docker.com/builds/Windows/x86_64/docker-latest.zip and copy the executable file named "docker.exe" from the "docker" subdirectory to a local folder. To install the Docker client for macOS, open https://get.docker.com/builds/Darwin/x86_64/docker-latest.tgz and copy the executable file named "docker" from the "docker" subdirectory to a local folder. To install the Docker client for Linux, open https://get.docker.com/builds/Linux/x86_64/docker-latest.tgz and copy the executable file named "docker" from the "docker" subdirectory to a local folder. (You can ignore the other files in the "docker" subdirectory.)
After installing the Docker client, add the directory in which it was installed to the PATH environment variable so you can execute docker commands on the command line without prefacing them with path names.
You do not need to install the Docker client if you already have Docker (or Docker Toolbox) installed on your machine.
This hands-on lab includes the following exercises:
Estimated time to complete this lab: 60 minutes.
Before you can deploy Docker images to Azure, you must create an Azure Container Service. And in order to create an Azure Container Service, you need a public/private key pair for authenticating with that service over SSH. In this exercise, you will create an SSH key pair. If you are using macOS or Linux, you will create the key pair with ssh-keygen. If you are running Windows instead, you will use a third-party tool named PuTTYGen.
Unlike macOS and Linux, Windows doesn't have an SSH key generator built in. PuTTYGen is a free key generator that is popular in the Windows community. It is part of an open-source toolset called PuTTY, which provides the SSH support that Windows lacks.
If you are running Windows, skip to Step 6. Otherwise, proceed to Step 2.
On your Mac or Linux machine, launch a terminal window.
Execute the following command in the terminal window:
ssh-keygen
Press Enter three times to accept the default output file name and create a key pair without a passphrase. The output will look something like this:
Generating a public/private key pair
Use the following commands to navigate to the hidden ".ssh" subdirectory created by ssh-keygen and list the contents of that subdirectory:
cd ~/.ssh
ls
Confirm that the ".ssh" subdirectory contains a pair of files named id_rsa and id_rsa.pub. The former contains the private key, and the latter contains the public key.
Leave the terminal window open and proceed to Exercise 2. The remaining steps in this exercise are for Windows users only.
Launch PuTTYGen and click the Generate button. For the next few seconds, move your cursor around in the empty space in the "Key" box to help randomize the keys that are generated.
Generating a public/private key pair
Once the keys are generated, click Save public key and save the public key to a text file named public.txt. Then click Save private key and save the private key to a file named private.ppk. When prompted to confirm that you want to save the private key without a passphrase, click Yes.
Saving the public and private keys
You now have a pair of files containing a public key and a private key. Remember where these files are located, because you will need them in subsequent exercises.
Now that you have an SSH key pair, you can create and configure an Azure Container Service. In this exercise, you will use the Azure Portal to create an Azure Container Service for running Docker containers.
Open the Azure Portal in your browser. If you are asked to log in, do so using your Microsoft account.
Click + New, followed by Containers and Azure Container Service.
Creating a container service
In the "Basics" blade, enter a name for the service. Select Create new under Resource group and enter the resource-group name "ACSLabResourceGroup" (without quotation marks). Select the location nearest you under Location, and then click the OK button.
Basic settings
In the "Master configuration" blade, select Swarm as the orchestrator.
Swarm, DC/OS, and Kubernetes are popular open-source orchestration tools that enable you to deploy clusters containing thousands or even tens of thousands of containers. (Think of a compute cluster consisting of containers rather than physical servers, all sharing a load and running code in parallel.) All three are preinstalled in Azure Container Service, with the goal being that you can use the one you are most familiar with rather than learn a new tool. Swarm is Docker's own native clustering tool.
Enter a DNS name prefix in the DNS name prefix box. (The prefix doesn't have to be unique across Azure, but it does have to be unique to a data center. To ensure uniqueness, you should include birth dates or other personal information that is unlikely to be used by other people working these exercises. Otherwise, you may see a green check mark in the DNS name prefix box but still suffer a deployment failure.) Enter "dockeruser" (without quotation marks) for User name and the public key that you generated in Exercise 1 for SSH public key. Then set Master count to 1 and click OK.
You can retrieve the public key from the id_rsa.pub or public.txt file that you generated in Exercise 1 and paste it into SSH public key box.
Master configuration settings
In the "Agent configuration" blade, set Agent count to 2. Then click OK.
When you create an Azure Container Service, one or more master VMs are created to orchestrate the workload. In addition, an Azure Virtual Machine Scale Set is created to provide VMs for the "agents," or VMs that the master VMs delegate work to. Docker container instances are hosted in the agent VMs. By default, Azure uses a standard DS2 virtual machine for each agent. These are dual-core machines with 7 GB of RAM. Agent VMs are created as needed to handle the workload. In this example, there will be one master VM and up to two agent VMs.
Agent configuration settings
In the "Summary" blade, review the settings you selected. Then click OK.
Settings summary
Deployment typically takes 5 to 10 minutes. You can monitor the status of the deployment by opening the blade for the resource group created for the container service. Click Resource groups in the ribbon on the left. Then click the resource group named "ACSLabResourceGroup."
Opening the resource group
Wait until "Deploying" changes to "Succeeded," indicating that the service has been successfully deployed. You can click the Refresh button at the top of the blade to refresh the deployment status.
Successful deployment
When the deployment completes successfully, you will see all the resources that comprise the container service in the resource group. The next step is to open a secure connection to the service.
In this exercise, you will establish an SSH connection to the container service you deployed in Exercise 2 so you can use the Docker client to create Docker containers and run them in Azure.
After the container service finishes deploying, return to the blade for the "ACSLabResourceGroup" resource group. Then click the resource named swarm-master-lb-xxxxxxxx. This is the master load balancer for the swarm.
Opening the master load balancer
Hover over the IP address under "Public IP address." Wait for a Copy button to appear, and then click it to copy the master load balancer's IP address to the clipboard.
Copying the master load balancer's public IP address
If you are running Windows, skip to Step 8. Otherwise, proceed to Step 4.
On your Mac or Linux machine, return to the terminal window you opened in Exercise 1 and make sure you are still in the ".ssh" directory containing the key pair that you generated.
Execute the following command to SSH in to the Azure Container Service, replacing ipaddress with the IP address on the clipboard (and deleting the DNS name after the IP address):
ssh dockeruser@ipaddress -p 2200 -L 22375:<IP_ADDRESS>:2375
The purpose of the -L switch is to forward traffic transmitted through port 22375 on the local machine (that's the port used by the docker command you will be using shortly) to port 2375 at the other end. Docker Swarm listens on port 2375. The -p switch instructs SSH to use port 2200 rather than the default 22. The load balancer you're connecting to listens on port 2200 and forwards the SSH messages it receives to port 22 on the master VM.
If asked to confirm that you wish to connect, answer yes. Once connected, you'll see a screen that resembles the one below.
Observe that you didn't have to enter a password. That's because the connection was authenticated using the public/private key pair you generated in Exercise 1. Key pairs tend to be much more secure than passwords because they are cryptographically strong.
Successful connection
Leave the terminal window open and proceed to Exercise 4. The remaining steps in this exercise are for Windows users only.
Launch PuTTY and paste the IP address on the clipboard into the Host Name (or IP address) box. (Be sure to delete the DNS name after the IP address). Set the port number to 2200 and type "ACS" (without quotation marks) into the Saved Sessions box. Click the Save button to save these settings under that name.
Why port 2200 instead of port 22, which is the default for SSH? Because the load balancer you're connecting to listens on port 2200 and forwards the SSH messages it receives to port 22 on the master VM.
Configuring a PuTTY session
In the treeview on the left, click the + sign next to SSH, and then click Auth. Click the Browse button and select the private-key file that you created in Exercise 1.
Entering the private key
Select Tunnels in the treeview. Then set Source port to 22375 and Destination to <IP_ADDRESS>:2375, and click the Add button.
The purpose of this is to forward traffic transmitted through port 22375 on the local machine (that's the port used by the docker command you will be using shortly) to port 2375 at the other end. Docker Swarm listens on port 2375.
Configuring the SSH tunnel
Click Session at the top of the treeview. Click the Save button to save your configuration changes, and then click Open to create a secure SSH connection to the container service. If you are warned that the server's host key isn't cached in the registry and asked to confirm that you want to connect anyway, click Yes.
Opening a connection to the container service
An SSH window will open and prompt you to log in. Enter the user name ("dockeruser") that you specified in Exercise 2, Step 4. Then press the Enter key. Once connected, you'll see a screen that resembles the one below.
Observe that you didn't have to enter a password. That's because the connection was authenticated using the public/private key pair you generated in Exercise 1. Key pairs tend to be much more secure than passwords because they are cryptographically strong.
Successful connection
Now that you're connected, you can run the Docker client on your local machine and use port forwarding to execute commands in the Azure Container Service. Leave the SSH window open while you work through the next exercise.
Now comes the fun part: creating a Docker image and running it inside a container in Azure. If you haven't already installed the Docker client, refer to the instructions at the beginning of this lab to download and install the Docker client for your operating system.
Open a terminal window (macOS or Linux) or a Command Prompt window (Windows) and navigate to the "resources" subdirectory of this lab. It contains the files that you will build into a container image. If the "resources" subdirectory doesn't already contain a subdirectory named "output," use the following command to create one:
mkdir output
Take a moment to examine the contents of the "resources" subdirectory. It contains a file named Dockerfile, which contains the commands Docker will use to build a container image. It also contains a Python script named convertimages.py, a subdirectory named "input," and a subdirectory named "output." The "input" subdirectory contains several color JPG images. The Python script enumerates the files in the "input" subdirectory, converts them to grayscale, and writes the grayscale images to the "output" subdirectory.
If you are running macOS or Linux, execute the following command in the terminal window:
export DOCKER_HOST=tcp://<IP_ADDRESS>:22375
If you are running Windows instead, execute this command in the Command Prompt window:
set DOCKER_HOST=tcp://<IP_ADDRESS>:22375
This command directs the Docker client to send output to localhost port 22375, which you redirected to port 2375 in the Azure Container Service in the previous exercise. Remember that port 2375 is the one Docker Swarm listens on. The commands that you execute in the next few steps are typed into a local terminal window, but they are executed in the container service you deployed to the cloud using the SSH tunnel that you established in the previous exercise.
Still in the "resources" subdirectory, execute the following command to create a container image named "ubuntu-convert" containing the Python script as well as the "input" and "output" subdirectories and their contents. Be sure to include the period at the end of the command:
docker build --no-cache --tag ubuntu-convert .
Wait for the command to finish executing. (It will take a few minutes for Docker to build the container image.) Then execute the following command to list the images that are present, and confirm that the list contains an image named "ubuntu-convert:"
docker images
Now execute the following command to start the container image running and name the container "acslab:"
docker run -dit --name acslab ubuntu-convert /bin/bash
The container is now running. The next task is to execute the Python script in the root of the file system in the running container. To do that, execute the following command:
docker exec -it acslab python /convertimages.py
If the Python script ran successfully, the "output" subdirectory in the container should contain grayscale versions of the JPG files in the "input" subdirectory. Use the following command to copy the files from the "output" subdirectory in the container to the "output" subdirectory on the local machine:
docker cp acslab:/output .
Because you are still in the "resources" subdirectory, this command will copy the grayscale images to that directory's "output" subdirectory.
Stop the running container by executing the following command:
docker stop acslab
Type the following command to delete the "acslab" container:
docker rm acslab
List the contents of the "output" subdirectory under the "resources" subdirectory that you are currently in. Confirm that it contains eight JPG files copied from the container.
Open one of the JPG files and confirm that it contains a grayscale image like the one pictured below.
Grayscale image copied from the container
Congratulations! You just created a Docker container image and ran it in a Docker container hosted in Azure. You can close the SSH window now because you are finished using the SSH connection.
When virtual machines are running, you are being charged — even if the VMs are idle. Therefore, it's advisable to stop virtual machines when they are not in use. You will still be charged for storage, but that cost is typically insignificant compared to the cost of an active VM.
Your container service contains a master VM that needs to be stopped when you're not running containers. The Azure Portal makes it easy to stop virtual machines. VMs that you stop are easily started again later so you can pick up right where you left off. In this exercise, you will stop the master VM to avoid incurring charges for it.
In the Azure Portal, open the blade for the "ACSLabResourceGroup" resource group. Click the virtual machine whose name begins with swarm-master to open a blade for the master VM.
Opening a blade for the master VM
Click the Stop button to stop the master VM. Answer Yes when prompted to verify that you wish to stop it.
Stopping the master VM
There is no need to stop the agent VMs. They are part of an Azure Virtual Machine Scale Set and are automatically spun up and down as needed by the master VM. Note that if you wish to run containers again in this container service, you will need to restart the master VM.
Resource groups are a useful feature of Azure because they simplify the task of managing related resources. One of the most practical reasons to use resource groups is that deleting a resource group deletes all the resources it contains. Rather than delete those resources one by one, you can delete them all at once.
In this exercise, you will delete the resource group created in Exercise 2 when you created the container service. Deleting the resource group deletes everything in it and prevents any further charges from being incurred for it.
In the Azure Portal, open the blade for the "ACSLabResourceGroup" resource group. Then click the Delete resource group button at the top of the blade.
Deleting a resource group
For safety, you are required to type in the resource group's name. (Once deleted, a resource group cannot be recovered.) Type the name of the resource group. Then click the Delete button to remove all traces of this lab from your account.
After a few minutes, you will be notified that the resource group was deleted. If the deleted resource group still appears in the "Resource groups" blade, click that blade's Refresh button to update the list of resource groups. The deleted resource group should go away.
The Azure Container Service makes it easy to run apps packaged in Docker containers in the cloud without having to manage servers or install a container stack yourself. Container images are smaller than VM images, they start faster, and they typically cost less since a single VM can host multiple container instances. More importantly, Docker containers can be hosted in other cloud platforms such as Amazon Web Services (AWS). If you want to avoid being tied to a single cloud platform, containers are a great way to achieve that independence.
Copyright 2017 Microsoft Corporation. All rights reserved. Except where otherwise noted, these materials are licensed under the terms of the MIT License. You may use them according to the license as is most appropriate for your project. The terms of this license can be found at https://opensource.org/licenses/MIT.


Before Change
None
self.ext_params["field"] = be.dot(scaled_units[0], weights[0])
for i in range(1, len(weights)):
self.ext_params["field"] += be.dot(scaled_units[i], weights[i])
if beta is not None:
self.ext_params["field"] *= be.broadcast(
beta,
self.ext_params["field"]
)
self.ext_params["field"] += be.broadcast(
self.int_params["loc"],
self.ext_params["field"]
)
def derivatives(self, vis, hid, weights, beta=None):
Compute the derivatives of the intrinsic layer parameters.
After Change
for i in range(1, len(weights)):
field += be.dot(scaled_units[i], weights[i])
if beta is not None:
field *= be.broadcast(beta,field)
field += be.broadcast(self.int_params.loc, field)
self.ext_params = IsingLayer.IntrinsicParams(field)
def derivatives(self, vis, hid, weights, beta=None):
Compute the derivatives of the intrinsic layer parameters.


Before Change
// regex still works.
m = re.search(expr, compat.exec_command("/sbin/ldconfig", "-r"))
else:
m = re.search(expr, compat.exec_command("/sbin/ldconfig", "-p"))
if m:
lib = m.group(0)
// Look in the known safe paths.
if lib is None:
// Architecture independent locations.
paths = ["/lib", "/usr/lib"]
// Architecture dependent locations.
After Change
PyInstaller.depend.utils.load_ldconfig_cache()
lib = PyInstaller.depend.utils.LDCONFIG_CACHE.get(name)
if lib:
assert os.path.isfile(lib)
// Look in the known safe paths.
if lib is None:
// Architecture independent locations.


Each year, the society of automotive engineers (SAE), holds a series of collegiate competitions called mini Baja. The competition rules level the playing field by requiring the same Briggs and Stratton engine to power all vehicles in the race. Therefore, innovation and optimization in the driveline result in the each cars speed and acceleration. The latest project on the Michigan Baja Racing driveline is the development of an electronically controlled variable transmission (EVT). A combustion engine has a maximized torque at a certain rotational speed (RPM) of the crankshaft. In order to maximize the torque at all times, the EVT modifies the ratio between the gearbox and the engine by modifying the distance between the clutches attached to the engine crankshaft. For the EVT, a Hall Effect sensor senses the rotational speed of the shaft and a hybrid stepper motor linear actuator adjusts clutch distance. A single input single output closed loop system with a classical controller was used in the final prototype.
Other Contributors: Brennan Garrett, Nigel Leung, Jeremy Henzel, KC Bruner
The main goal of our project is to design a system that can automatically balance a ball on a plate. Our final demo not only achieved our base goal of balancing a ball on a plate but we were able to succeed in many of our stretch goals as well. Those goals included tracking a variety of shapes and also allowing the user to “draw” their own shapes. We did the latter using a joystick input. In order to accomplish our project we were tasked with selecting components and developing software to successfully balance the ball on a plate. For our sensor, we used a Raspberry Pi computer. With a Pi camera, we were able to extract ball coordinates with a variety of signal processing algorithms. An Arduino was used as the controller and sent pwm signals to two servos which acted as our actuators.
Other Contributors: Paul Domanico, Steven Murray
This will be my third semester leading weekly lab sections for Embedded Control Systems. Embedded Control Systems is a senior/first year graduate level course that teaches students from diverse backgrounds how to implement controls via c code and Simulink autocode generation. We use technology relevant to the local automotive industry, including the Freescale MPC 5553 microcontroller and a CAN network. We also use Mathworks tools, Matlab, Simulink, Stateflow, and Real Time Workshop for modeling, analysis, and (in the last stage of the course) autocode generation.
Our system comprised of an infrared light and a phototransistor to sense the height of the ball. The actuator of the system was an electromagnet. A voltage to current circuit was designed for the system using an OPA547T operational amplifier as well. A lead controller was chosen to stabilize the system in order to reduce the effects of high frequency noise. No integral was term was used as steady state error was not a priority of ours to mitigate. The controller was implemented in LabVIEW with a national instruments daq.
Instead of using a classical controller for this system, full state feedback was implemented. The team tracked rotational position and speed of both the horizontal arm and the pendulum of the system. Using the linear quadratic regulator function in matlab, we were able to determine the controller gain applied to each state in the feedback loop. In addition to the balancing controller, we also created a swing up controller. This controller used the angle and speed of the pendulum arm to determine how fast and in what direction to turn the horizontal arm to continuously increase the height of the pendulum swing.
Other Contributors: Akshay Bhardwaj, Chien-Wen Pan, Yi-Shun Wang, Wei Hon Yap


With this node you can read IN Cell Analyzer 1000 data in xls format. The node description contains the basics, this page shows the details.
In The folder of xls files:
group select the folder of xls files.
Using the [Browse] button you may select an individual xls file also. Selection of an xls file will
actually select the folder of it.
You can rearrange the files in the xls list using the [^] and [v] buttons.
It is important to select the xls files you want to analyse. By default none of them is selected.
The files are grouped by the Replicate count to create the replicates. So if you have 3 replicates, then the forth xls file will belong to the second plate group and the first replicate group.
You have to select the proper Well count and also the Plate count.
Optionally you can select an annotation file to have the data and your annotation together.
There must be a (the second) sheet with name: Summary by wells.
The first column should contain the well identifiers in format: A - 1 from the 4th row.
The header of the data is obtained from the second row, from the 3rd column.
The data starts from 4th row in the 3rd column.
This is a tab separated file with Plate, Well, GeneID, GeneSymbol header.
The plate numbering should start from 1.
The format of values in the Well column is like: A01.
For more information consult the cellHTS2 complete manual, Probe annotation section.
If there are more annotation than input data, then you will get an error.


Responsive
This Web Can Be Accessed by any devices such as notebook , pc , smartphone , tablet , and giving a structured design etc
Easy To Use
This web makes the user comfortable with a lot of easy options
Comfortable Experience
The Combination of Artcoloring on the web makes our eyes happy likes flying in the outer of this world because we build it with space theme


Created: 2021-04-20 Tue 00:02
I’m calling this talk “This changes everything.” In it I share with you a handful of “ah-hah” moments in my life when I have come to the conclusion that I can’t think of Christian theology in the same way any more. In our final class I wanted to share my thoughts with you as examples of one person’s grappling with the developments of the modern age. It is not in order to convince you that my conclusions ought to be your conclusions. I am convinced, however, that contemporary Christian thought – the “end” of our course this semester – can not be done as “business as usual.” I hope it will prompt a fitting concluding conversation for us.
looked at contain one or more “This changes everything” developments.
What is true is more like telling stories and less like philosophical or scientific propositions.
When the great Rabbi Israel Baal Shem Tov saw misfortune threatening the Jews it was his custom to go into a certain part of the forest to meditate. There he would light a fire, say a special prayer, and the miracle would be accomplished and the misfortune averted. Later, when his disciple, the celebrated Magid of Mezritch, had occasion, for the same reason, to intercede with heaven, he would go to the same place in the forest and say: “Master of the Universe, listen! I do not know how to light the fire, but I am still able to say the prayer.” And again the miracle would be accomplished.
Still later, Rabbi Moshe-Leib of Sasov, in order to save his people once more, would go into the forest and say: “I do not know how to light the fire, I do not know the prayer, but I know the place and this must be sufficient.” It was sufficient and the miracle was accomplished. Then it fell to Rabbi Israel of Rizhyn to overcome misfortune. Sitting in his armchair, his head in his hands, he spoke to G-d: “I am unable to light the fire and I do not know the prayer; I cannot even find the place in the forest. All I can do is to tell the story, and this must be sufficient.” And it was sufficient.
G-d made man because He loves stories.
So begins Elie Wiesel’s famous book, “Gates of the Forest.” - Wiesel
re. summary
Søren Kierkegaard. Placher treats him as a reaction to Hegel. He gave the world the concept of “Christendom” which is to be contrasted with “Christian faith.”
Another theologian of the mid-20th c., John Macquarrie, described the discipline of theology as “God talk” – i.e. using words to understand God and God’s interaction with humans.
If we can only understand “looking backwards” – as we have done in this course – but can only live going forwards – i.e. without understanding, only trust – then doing Christian theology is either not about real life or not about understanding.
As one of my teachers put it, “If that is true it’s important.”
Certain events of the last century, events that occurred with complicity and often defenders from the Christian faith, call into question the fundamental authority of the faith.
the parent religion, Judaism. From the beginning, there has been an incipient sense of, “We’re not THAT.”
“Old Testament”. The Old testament is done away with and the New replaces it.
That’s a crude and over-simplistic way of putting it, but it expresses what is I believe a deep conviction of the Christian world-view.
Testament itself.
Holocaust“ call into question that basic element of Christianity.
New – in the light of Christian complicity in anti-semitism over the course of 2,000 years?
but a blight on the whole traditional approach to Christian thought?
earth, doesn’t Christian thought have something to contribute to that?
Going back to the beginning of our semester, we looked at various “proofs of the existence of God.”
At various points along the way, we have considered “theodicy” questions, questions arising out of conflict between the existence of evil and the profession of belief in an all-powerful and all-loving God.
If it is the case that Christian thought has lumbered under the burden of carrying a Greco-Roman conception of divinity while ignoring the possibility that such a view of the divine may itself be “un-Christian” – well, that might make all the difference.“
There are many in today’s environment who have concluded that it is impossible to defend “classical theism”.
monotheism. Whereas most monotheists agree that God is, at minimum, all-knowing, all-powerful, and completely good [2]
in contrast to other conceptions such as
Process theology in the 20th c., descending from the philosophical work of Whitehead and the theological work of Charles Hartshorne, is the prominent expression of an alternative to “classical theism”.
goes beyond the traditions we have inherited. For myself, there is a fictional image, a narrative expression, that seems more true than any of the philosophical expressions I have encountered. It comes from the memoir of the Holocaust, Night, by Elie Wiesel.
The best-known scene in Elie Wiesel’s book “Night” is apparently that of the execution. Three prisoners, two of them adults and the third a little boy, were hanged at the Buna camp in Auschwitz after being implicated by the Gestapo in the discovery of a weapons cache. The adults died immediately. But the little boy, who did not weigh much, hovered between life and death for more than half an hour.
“Where is God?” someone standing behind Wiesel asked, and Wiesel relates in the book that a voice from inside him replied: “Here, He is. He is hanging here on the gallows.” Haaretz
scriptures. Is it compatible with “classical theism?”
If this is true it’s important.
What we know? How do we know? What if there is only contextual knowledge?
Math, Physics and sciences of all kinds have traditionally been intertwined with Theology. There is considerable energy spent in resisting those interconnections in the modern American context.
What we seem to “know” from a broad perspective is a vast interconnected universe, from the impossibly small to the impossibly large. But the impossible is not just possible, but presumed to be real.
and mysticism.
“A particle is not a separate entity but a set of relationships. The world is an interconnected tissue of events, a dynamic unbroken whole. Scientists are no longer observers but participants. And physics and mysticism converge in striking parallels, leading back full circle: A powerful awareness lies dormant in these discoveries of modern physics. An awareness of the hitherto- unsuspected powers of the mind to mold reality, rather than the other way around.”
Article Source: http://ezinearticles.com/600428 see also and also from the little Zen companion - If this is true, it’s important. This makes all the difference.
The world we live in is not anything like the world of our grandparents or patriarchs and matriarchs. What is real in our world is often beyond imagining.
It’s not all about us. String exercise
video of scale upwards This is a graphic view of the universe that we look out upon. It is impossibly big and huge and amazing. It’s not all about us.
If it is true, it is important. This makes all the difference.
[1] Stanley Hauerwas PhD (2005) Chapter 6. Must a Patient Be a Person to Be a Patient?, Journal of Religion, Disability & Health, 8:3-4, 113-119, DOI: 10.1300/J095v08n03\13 Link Another overview of philosophical heritage
[2] Philosophy of Religion: An Anthology. Cengage Learning.
Created by Dale Hathaway.


I like to wonder whenever I can, but most favorite is
I am a great grey cat, which can walk whenever HE want!
Return to me


WITNESS LIST Human Services Committee April 23, 2003-2:30P HB 2059 For: Arispe, Don (Self and San Antonio Kinship Care Collabration) Bower, Bruce (Texas Kincare Task Force) Carter, Candice (AARP) Shaw, Linda (AARP) HB 2429 For: Holland, Narda (Methodist Retirement Communities - Crestiview) Ogrin, Richard (Methodist Retirement Communities) HB 2852 On: Bivens, Carolyn (Adult Protective Services - DPRS) HB 2984 For: Barr, Mary (Self and Communities In Schools - Texas) Loving, Don (Self and Communities In Schools - Central Texas) HB 3059 For: Bower, Bruce (Texas Senior Advocacy Coalition) Dyer, Heather (Self) Higgins, Carlos (Texas Silver Haired Legislature) Kyker, Chris (Texas Silver Haired Legislature) Against: Vasek, Heather (Texas Association for Home Care) On: Bivins, Carolyn (Adult Protective Services - DPRS) HB 3354 For: Henry, Reverend Mildred (Self) Rich, Sid (Texas Association of Residential Care Communities) Against: Carter, Candice (AARP) On: Thomason, Dave (Texas Association of Homes and Services for the Aging) HCR 125 For: Bower, Bruce (Texas Senior Advocacy Coalition)


HEARTBREAKERS
Reviewed by Harvey Karten MGM Director: David Mirkin Writer: Robert Dunn,Paul Guay, Stephen Mazur Cast: Sigourney Weaver, Jennifer Love Hewitt, Ray Liotta, Jason Lee, Anne Bancroft, Jeffrey Jones, Gene Hackman, Nora Dunn, Ricky Jay.
Joan Baez, while hardly a stay-at-home woman, loved to sing the lyrics of Marty Tipton's Appalachian folk song during the seventies: "Hard is the fortune of all womankind,/ She's always controlled, she's always confined,/ Controlled by her parents until she's a wife,/ A slave to her husband all the rest of her life." This was obviously before she saw the movie "Heartbreakers," definitive proof that men are the weaker sex--or, as Harry Belafonte would chime in, "Put the man and the woman together, to see which one is smarter," coming the conclusion that the latter will always emerge victorious.
"Heartbreakers could be called the women's revenge for Frank Oz's 1988 comedy, "Dirty Rotten Scoundels," which despite the presence of Oscar ceremony host Steve Martin is no more than a pleasant parody about a male con artist who takes women for a ride. A better one, Preston Sturges's "The Lady Eve," featured Barbara Stanwyck as a ripoff maestro who makes the moves on the wealthy Henry Fonda.
The David Mirkin ("Romy and Michel's High School Reunion") story is of two strong women not unaccustomed to twisting men about their fingers by setting them up in a scam which, looking at its possibilities in the real world, simply would not result in capturing any bucks at all. The mother-daughter team of Angela Nardino (Sigourney Weaver) and Wendy (Jennifer Love Hewitt) sets up men by having them fall in love with and marrying mom who, finding an excuse not to consummate the union on the wedding night, arranges to have her little girl organize them into a compromising position. Caught in the act (although nothing really happens), the men come across with fat settlements rather than have the cases go before a court which--in at least one case--would have the effect of ruining a crooked guy's profitable business.
The film was a big surprise for me as I had gone into this thinking it would be yet some more commercial pap, more sentimental than cynical and with gags that would not challenge the mentality of my 10-year-old terrier. Yet "Heartbreakers" was involving throughout its two-hour running time and did not at all depend on the expertise of Gene Hackman to bring it to life a half-hour into the game.
Fans of "Hannibal" will get a kick out of seeing Ray Liotta with his head screwed back on. Liotta performs in the role of a stolen-car serviceman, Dean Cumanno, who falls madly in love with the sexy Angela only to be left high and literally dry on his icy wedding night. The following morning, his attention is riveted on his pretty receptionist, Wendy, and while she is engaging him under the desk the two are caught in the act by the "heartbroken" Angela. Looking to make one last score before they hang up their uplift bras, the two hone in on aging billionaire tobacco executive, William B. Tensy (Gene Hackman), figuring that even if he doesn't buy the daughter's mock seduction after marrying Angela, he might do them a favor by dropping dead, thereby leaving them the major part of three billion dollars. Perpetually puffing on his product, the liver-spotted Tensy not only kills a parrot instantly with second-hand smoke but brags about his experiments addicting nine-year-olds with the weed. This movie does more to deride the tobacco industry than Michael Mann's "The Insider" could.
In the film's only sentimental motif, Wendy risks falling in love with Jack Withrowe (Jason Lee), owner of prime property in California's Palm Beach--the very hazard that her mother had warned her against.
The fifty-one-year-old Sigourney Weaver never looked better, figuratively running rings around her adorable but too outwardly meanspirited daughter played by Hewitt. The mother-daughter combination works well, giving the audience the impression of a love-hate relationship between a girl of scarcely twenty years old wanting independence and her own life while at the same caring deeply about her and respecting the moneymaking schemes on which they thrive. Jason Lee does fine as a somewhat goofy and naive owner of a bar, unwilling to see that he is being taken for a ride despite ample evidence, and Saturday Night Live's Nora Dunn has a grand moment as Miss Madress, a billionaire's housekeeper not fond of letting any woman into the life of her aging employer.
Except for Lee's character, there's no one among these dirty rotten scoundrels that you'd want to take home (wait: I take that back), but who cares? This is a well-paced, genuinely amusing piece of work that subverts the tobacco industry as well as the more potentially deadly institution of marriage.
Rated PG-13. Running time: 123 minutes. (C) 2001 by Harvey Karten<EMAIL_ADDRESS>The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


FieldIDsfileName - the name of an open database file (local or remote).Related fields are returned as TableID::RelatedFieldID.If no parameter is specified for fileName, FileMaker returns results for the current file.FieldIDs(“Customers”;””) returns IDs of all unique fields in the default table of Customers.FieldIDs(“Customers”;”Layout#5”) returns IDs of all unique fields, including related fields, on Layout#5 in Customers.


| pgpool-II 4.0.3 Documentation | |||
|---|---|---|---|
| Prev | Up | Chapter 4. Server Setup and Operation | Next |
Pgpool-II provides a interface for administrators to perform management operation, such as getting Pgpool-II status or terminating Pgpool-II processes remotely. pcp.conf is the user/password file used for authentication by this interface. All operation modes require the pcp.conf file to be set. A $prefix/etc/pcp.conf.sample file is created during the installation of Pgpool-II. Copy the file as $prefix/etc/pcp.conf and add your user name and password to it.
$ cp $prefix/etc/pcp.conf.sample $prefix/etc/pcp.conf
An empty line or a line starting with # is treated as a comment and will be ignored. A user name and its associated password must be written as one line using the following format:
username:[md5 encrypted password]
[md5 encrypted password] can be produced with the $prefix/bin/pg_md5 command.
$ pg_md5 your_password 1060b7b46a3bd36b3a0d66e0127d0517
If you don't want pass the password as the argument, execute pg_md5 -p.
$ pg_md5 -p password: your_password
The pcp.conf file must be readable by the user who executes Pgpool-II.


2 references to GetForegroundWindow
System.Management.Automation (2)
engine\NativeCommandProcessor.cs (2)
2234
IntPtr savedForeground = ConsoleVisibility.
GetForegroundWindow
();
2255
if (savedForeground != IntPtr.Zero && ConsoleVisibility.
GetForegroundWindow
() != savedForeground)


authorization steps
on first bounce
should save current step
should receive a redirect
on return from Wordpress
should save state
batch api
get posts and comments
returns correct response
can extract latest comment
comments api
get comments
posts api
create new post
get posts
edit post
delete post
get sites
returns users projects
default settings
exposes defaultSettings method


Hello friends, I am Mainframe System Programmer at IBM India Pvt. Ltd. Gurugram. I am working here since last 2 year. I love to code and I'm freak coder. I'm always eager to know and innovate new things in technology and I'm passionate towards achieving my goals. Apart from studies, I am fan of Cricket and most specifically I am big fan of Yuvraj Singh. I like to play guitar. I dream to be a guitarist. I am full package of sporty and positive attitude..!
About my skillsStandard Markup Language For Creating Web Pages
Language That Describes The Style Of a HTML Document
JavaScript Is The Easy Programming Language of HTML and The Web
Build responsive, mobile-first projects on the web with the world's most popular front-end component library
Library to make use JavaScript on websites more easier
Allows web pages to be updated asynchronously by exchanging data with a web server behind the scenes
Programming Language and Computing Platform
System Software For Creating and Managing Databases


Match Play. Red leads 4-2 to 7. How should Red play 53?
pips Red=116 White=104
(CorrectAnswer= 0/0, ErrorScore= 0)
Both sides are running out of time and the first to break will be at a disadvantage. This is not the time for Red to run, either with 21/13 or 21/18, 21/16.
He must hold the status quo with 8/3, 6/3 and wait for White’s position to deteriorate. Anything other than 8/3, 6/3 is blunder. Patience is a virtue!
He must hold the status quo with 8/3, 6/3 and wait for White’s position to deteriorate. Anything other than 8/3, 6/3 is blunder. Patience is a virtue!
1. Cubeful 2-ply 8/3 6/3 Eq.: +0.221 0.568 0.114 0.004 - 0.432 0.076 0.001 2. Cubeful 2-ply 21/18 21/16 Eq.: +0.109 (-0.111) 0.551 0.102 0.004 - 0.449 0.126 0.001 3. Cubeful 2-ply 8/3 5/2 Eq.: +0.061 (-0.160) 0.516 0.117 0.004 - 0.484 0.106 0.001 4. Cubeful 2-ply 8/5 8/3 Eq.: +0.055 (-0.166) 0.504 0.104 0.003 - 0.496 0.087 0.001 5. Cubeful 0-ply 21/16 6/3 Eq.: -0.304 (-0.524) 0.438 0.129 0.006 - 0.562 0.247 0.003


{{ template "base" }}
The InterPlanetary File System
LeekPot is a leak site where sharing is rewarded. LeekPot Beta is a playground running on the monero stagenet network, only playmoney is in use.


Having qualified from University of Mumbai,India in 2000, Hemant Nemade spent significant time gaining a wide general surgical skills base leading to MS(2005)and then embarking on specialist urological training in India gaining considerable expertise. He underwent further sub specialist training in Minimally invasive, Urooncology and Paediatric Urology at Royal Marsden, King’s College Hospital and Great Ormond street Hospital in UK, obtaining the FRCS (Urol) in 2012.
During that time he developed particular interests in benign and malignant prostate and kidney disease and in the application of newer technologies in Urology. Hemant is currently a Consultant Urologist at Frimley Park Hospital in Surrey and delivers a breadth of services for general urological conditions, including general waterworks problems, scrotal swellings and penile conditions.
Beyond this, he provides a regional service for stones of kidney and ureter and prostate cancer.His remit to continue and enhance the provision of minimally invasive surgical treatments to patients through the department incorporating enhanced recovery techniques.His recognised expertise in the laser treatment and Urolift for treatment of the symptomatic benign prostate disease has led to his continued involvement in cutting edge developments in this and other technologies. He takes keen interest in improving patient safety and is member of the Governance committee of the trust.
Hemant has a strong research background and continues to research ways of improving prostate cancer diagnosis, including fusion guided targeted biopsies. and has presented widely in national and international meetings such as the American Urological association,European Association of Urology,British association Of urological Surgeons Société Internationale d'Urologie,Royal Society of medicine and Urological society of India.
Hemant has extensive experience in teaching both undergraduate and postgraduate medicine being a clinical and educational supervisor, undergraduate examiner for University College London and invited faculty on various national and international courses.
He has garnered several awards and prizes, including prizes for Gold Medal in Urology, National Board, India 2009 and Gold medal in General Surgery University of Mumbai,India. He was awarded the Best Surgical Teacher Prize in 2010.


This domain is operated
by Adsterra
Premium Ad Network
Publishers signup if you want to monetize your traffic.
Advertisers click here to run your ad campaings.
Other inquries — please feel free to contact us


***TODO: Add all of the crisis events here with a description and dates for each
This group of charts shows the behaviors of both your strategy and the benchmark during certain historical periods. We set the value of your strategy the same as the benchmark at the beginning of each crisis event, and the lines represent the cumulative returns of your strategy and benchmark from the beginning of the crisis event. The report only contains the crisis event charts whose periods are covered by your strategy.


| site_resources {rmarkdown} | R Documentation |
Determine which files within a given directory should be copied in order to serve a website from the directory. Attempts to automatically exclude source, data, hidden, and other files not required to serve website content.
site_resources(site_dir, include = NULL, exclude = NULL, recursive = FALSE)
site_dir |
Site directory to analyze |
include |
Additional files to include (glob wildcards supported) |
exclude |
Files to exclude (glob wildcards supported) |
recursive |
|
Character vector of files and directories to copy


Regional-Scale Climate Model Intercomparison Workshop (November
17-18, 1994)
Regional-Scale Climate Model Intercomparison Workshop (November
17-18, 1994)
Workshop agenda
Overview of IITAP/EES given by Dr. Gene
Takle, Iowa State University, during visit by Dr. Federico Mayor,
Director General, UNESCO
Report of the workshop
Participant list for the Mesoscale Climate Model
Intercomparison Workshop


Aligning Multiple Scenes into A Single Image Using Image Registration
The implemented image registration system is capable of aligning image pairs to a common coordinate system. It can process variable number of images and is invariant to input order. The steps for the implementation included: point feature detection, correspondence establishment, homography estimation, RANSAC, and image warping.


Registration
By Click this Our Terms and Conditions. You started with creating your own custom Terms and Conditions agreement.


 Batch breakdown Items All Accepted Fixes required Disallowed Year 2016 2015 2014 Month January February March April May June July August September October November December 87 items were accepted View these 3 items require fixes View these 3 items were not accepted View these {% endblock %}
Your next payment will be on the 19/02/2016
items
total value


OF MICE AND MEN A film review by Mark R. Leeper Copyright 1992 Mark R. Leeper
Capsule review: Loneliness and human pain are the subjects of perhaps the best short novel of American literature, Steinbeck's OF MICE AND MEN. This is a big- budget adaptation of the story and the budget may work against the effect. But the great story still makes a great film. Rating: low +2 (-4 to +4).
My introduction to John Steinbeck's OF MICE AND MEN was a terrific television production with Nicol Williamson as Lennie and George Segal as George. Envy me. At least as far as I am concerned no other production has been as moving. Steinbeck's very short novel is one of the greatest tragic stories of world literature, ranking (in my opinion) almost up to Hugo's LES MISERABLES. And it is probably shorter than Hugo's chapter on the Paris sewers. Actually, on my last reading--about a year ago--it occurred to me that what I was reading was not a novel at all, but a play in paragraph form. There is only minimal description in the novel, enough to set the scene, and the rest if dialogue. As I have heard subsequently, it was originally a play by Steinbeck and he later rewrote it in paragraph form. This 1992 adaptation is at least the fourth non-live version I have seen. Supposedly the classic version, but one I have not cared much for, is the 1940 film with Burgess Meredith and Lon Chaney, Jr. Nor was I fond of the 1981 television movie version with Robert Blake and Randy Quaid. Having seen three versions already that are close to the book and having read the book who knows how many times, I find it hard to rate the film as if it is a new story.
Now I am not going to tell you the plot of OF MICE AND MEN. If you do not already know, your assignment is either to read the book--it will take you only an hour or so--or to see the movie. Suffice it to say that Lennie Small (played by John Malkovich) is anything BUT small in stature, though he does have the mind of a child. He travels with George Milton (played by Gary Sinese), a reasonably sharp thinker who for reasons not immediately apparent chooses to partner with Lennie. What really drives the relationship is part of what this story is about and told sparsely and with eloquence by John Steinbeck.
Sinese, who also directed the film, does a fine job as George, a part that could easily be overshadowed by that of Lennie. Sinese has starred in stage versions of both OF MICE AND MEN and THE GRAPES OF WRATH.  Neither Ray Walston as Candy nor John Terry as Slim manage to look as grizzled as their characters call for, though Walston still carries off his role. Terry is just too handsome and young to be slim, in my opinion. But a lot of this film really is just too pretty for the film's own good. It seems too pleasant to "buck" barley in these golden surroundings.  Horton Foote's screenplay leaves most of the book intact but like the 1981 version adds sequences to the story. Any variation from the novel seems out of place, since the novel is so near to being a script.
By most measures this is a very good adaptation of a great book. It is a wonderful story that is an essay on loneliness and pain. It is the only film that literally brought tears to my eyes this year. As an adaptation of an often-dramatized novel, I give it a low +2 on the -4 to +4 scale. But if you do not know the story, *rush* to see this film. Then read the book.
Mark R. Leeper att!mtgzy!leeper<EMAIL_ADDRESS>.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


{% load static %}
The purpose of this website is to bring the opportunity of eat to anyone in any place at any hour. This website will let you to: