def i4vec_add_test ( ):
#*****************************************************************************80
#
## I4VEC_ADD_TEST tests I4VEC_ADD.
#
# Licensing:
#
# This code is distributed under the GNU LGPL license.
#
# Modified:
#
# 29 September 2014
#
# Author:
#
# John Burkardt
#
from i4vec_uniform_ab import i4vec_uniform_ab
print ''
print 'I4VEC_ADD_TEST'
print ' I4VEC_ADD adds two I4VECs.'
n = 10
seed = 123456789
lo = - n
hi = n
a, seed = i4vec_uniform_ab ( n, lo, hi, seed )
b, seed = i4vec_uniform_ab ( n, lo, hi, seed )
c = i4vec_add ( n, a, b )
print ''
print ' I A B C'
print ''
for i in range ( 0, n ):
print '%6d%6d%6d%6d' % ( i, a[i], b[i], c[i] )
#
# Terminate.
#
print ''
print 'I4VEC_ADD_TEST'
print ' Normal end of execution.'
return
def i4vec_frac_test():
#*****************************************************************************80
#
#% I4VEC_FRAC_TEST tests I4VEC_FRAC
#
# Licensing:
#
# This code is distributed under the GNU LGPL license.
#
# Modified:
#
# 26 May 2015
#
# Author:
#
# John Burkardt
#
from i4vec_print import i4vec_print
from i4vec_uniform_ab import i4vec_uniform_ab
n = 10
b = 1
c = 2 * n
seed = 123456789
print ''
print 'I4VEC_FRAC_TEST'
print ' I4VEC_FRAC: K-th smallest integer vector entry.'
print ' Using initial random number seed = %d' % (seed)
a, seed = i4vec_uniform_ab(n, b, c, seed)
i4vec_print(n, a, ' The array to search:')
print ''
print ' Fractile Value'
print ''
nh = (n // 3)
for k in range(1, n + 1, nh):
afrac = i4vec_frac(n, a, k)
print ' %6d %6d' % (k, afrac)
#
# Terminate.
#
print ''
print 'I4VEC_FRAC_TEST'
print ' Normal end of execution.'
return
def i4vec_sort_heap_index_a_test():
#*****************************************************************************80
#
## I4VEC_SORT_HEAP_INDEX_A_TEST tests I4VEC_SORT_HEAP_INDEX_A.
#
# Licensing:
#
# This code is distributed under the GNU LGPL license.
#
# Modified:
#
# 27 October 2014
#
# Author:
#
# John Burkardt
#
from i4vec_print import i4vec_print
from i4vec_uniform_ab import i4vec_uniform_ab
n = 20
print ''
print 'I4VEC_SORT_HEAP_INDEX_A_TEST'
print ' I4VEC_SORT_HEAP_INDEX_A creates an ascending'
print ' sort index for an I4VEC.'
b = 0
c = 3 * n
seed = 123456789
a, seed = i4vec_uniform_ab(n, b, c, seed)
i4vec_print(n, a, ' Unsorted array A:')
indx = i4vec_sort_heap_index_a(n, a)
i4vec_print(n, indx, ' Sort vector INDX:')
print ''
print ' I INDX(I) A(INDX(I))'
print ''
for i in range(0, n):
print ' %8d %8d %8d' % (i, indx[i], a[indx[i]])
#
# Terminate.
#
print ''
print 'I4VEC_SORT_HEAP_INDEX_A_TEST:'
print ' Normal end of execution.'
return
def i4vec_index_test():
#*****************************************************************************80
#
## I4VEC_INDEX_TEST tests I4VEC_INDEX;
#
# Licensing:
#
# This code is distributed under the GNU LGPL license.
#
# Modified:
#
# 27 May 2015
#
# Author:
#
# John Burkardt
#
from i4vec_print import i4vec_print
from i4vec_uniform_ab import i4vec_uniform_ab
n = 10
print ''
print 'I4VEC_INDEX_TEST'
print ' For an integer vector:'
print ' I4VEC_INDEX: first index of given value;'
seed = 123456789
i4_lo = -n
i4_hi = n
a, seed = i4vec_uniform_ab(n, i4_lo, i4_hi, seed)
i4vec_print(n, a, ' Input vector:')
i = (n // 2)
aval = a[i]
print ''
j = i4vec_index(n, a, aval)
print ' Index of first occurrence of %d is %d' % (aval, j)
aval = aval + 1
j = i4vec_index(n, a, aval)
print ' Index of first occurrence of %d is %d' % (aval, j)
#
# Terminate.
#
print ''
print 'I4VEC_INDEX_TEST:'
print ' Normal end of execution.'
return
def i4vec_frac_test ( ):
#*****************************************************************************80
#
#% I4VEC_FRAC_TEST tests I4VEC_FRAC
#
# Licensing:
#
# This code is distributed under the GNU LGPL license.
#
# Modified:
#
# 26 May 2015
#
# Author:
#
# John Burkardt
#
from i4vec_print import i4vec_print
from i4vec_uniform_ab import i4vec_uniform_ab
n = 10
b = 1
c = 2 * n
seed = 123456789
print ''
print 'I4VEC_FRAC_TEST'
print ' I4VEC_FRAC: K-th smallest integer vector entry.'
print ' Using initial random number seed = %d' % ( seed )
a, seed = i4vec_uniform_ab ( n, b, c, seed )
i4vec_print ( n, a, ' The array to search:' )
print ''
print ' Fractile Value'
print ''
nh = ( n // 3 )
for k in range ( 1, n + 1, nh ):
afrac = i4vec_frac ( n, a, k )
print ' %6d %6d' % ( k, afrac )
#
# Terminate.
#
print ''
print 'I4VEC_FRAC_TEST'
print ' Normal end of execution.'
return
def mono_next_grlex_test():
#*****************************************************************************80
#
## MONO_NEXT_GRLEX_TEST tests MONO_NEXT_GRLEX.
#
# Licensing:
#
# This code is distributed under the GNU LGPL license.
#
# Modified:
#
# 24 October 2014
#
# Author:
#
# John Burkardt
#
from i4vec_uniform_ab import i4vec_uniform_ab
m = 4
print ''
print 'MONO_NEXT_GRLEX_TEST'
print ' MONO_NEXT_GRLEX computes the next monomial'
print ' in M variables in grlex order.'
print ''
print ' Let M = %d' % (m)
a = 0
b = 3
seed = 123456789
for i in range(0, 10):
x, seed = i4vec_uniform_ab(m, a, b, seed)
print ''
print ' ',
for k in range(0, m):
print '%2d' % (x[k]),
print ''
for j in range(0, 5):
x = mono_next_grlex(m, x)
print ' ',
for k in range(0, m):
print '%2d' % (x[k]),
print ''
print ''
print 'MONO_NEXT_GRLEX_TEST'
print ' Normal end of execution.'
return
def mono_next_grlex_test ( ):
#*****************************************************************************80
#
## MONO_NEXT_GRLEX_TEST tests MONO_NEXT_GRLEX.
#
# Licensing:
#
# This code is distributed under the GNU LGPL license.
#
# Modified:
#
# 24 October 2014
#
# Author:
#
# John Burkardt
#
from i4vec_uniform_ab import i4vec_uniform_ab
m = 4
print ''
print 'MONO_NEXT_GRLEX_TEST'
print ' MONO_NEXT_GRLEX computes the next monomial'
print ' in M variables in grlex order.'
print ''
print ' Let M = %d' % ( m )
a = 0
b = 3
seed = 123456789
for i in range ( 0, 10 ):
x, seed = i4vec_uniform_ab ( m, a, b, seed )
print ''
print ' ',
for k in range ( 0, m ):
print '%2d' % ( x[k] ),
print ''
for j in range ( 0, 5 ):
x = mono_next_grlex ( m, x )
print ' ',
for k in range ( 0, m ):
print '%2d' % ( x[k] ),
print ''
print ''
print 'MONO_NEXT_GRLEX_TEST'
print ' Normal end of execution.'
return
def i4vec_index_test ( ): #*****************************************************************************80 # ## I4VEC_INDEX_TEST tests I4VEC_INDEX; # # Licensing: # # This code is distributed under the GNU LGPL license. # # Modified: # # 27 May 2015 # # Author: # # John Burkardt # from i4vec_print import i4vec_print from i4vec_uniform_ab import i4vec_uniform_ab n = 10 print '' print 'I4VEC_INDEX_TEST' print ' For an integer vector:' print ' I4VEC_INDEX: first index of given value;' seed = 123456789 i4_lo = -n i4_hi = n a, seed = i4vec_uniform_ab ( n, i4_lo, i4_hi, seed ); i4vec_print ( n, a, ' Input vector:' ) i = ( n // 2 ) aval = a[i] print '' j = i4vec_index ( n, a, aval ) print ' Index of first occurrence of %d is %d' % ( aval, j ) aval = aval + 1 j = i4vec_index ( n, a, aval ) print ' Index of first occurrence of %d is %d' % ( aval, j ) # # Terminate. # print '' print 'I4VEC_INDEX_TEST:' print ' Normal end of execution.' return
def i4vec_sort_heap_index_d_test ( ):
#*****************************************************************************80
#
## I4VEC_SORT_HEAP_INDEX_D_TEST tests I4VEC_SORT_HEAP_INDEX_D.
#
# Licensing:
#
# This code is distributed under the GNU LGPL license.
#
# Modified:
#
# 25 May 2015
#
# Author:
#
# John Burkardt
#
from i4vec_print import i4vec_print
from i4vec_uniform_ab import i4vec_uniform_ab
n = 20
print ''
print 'I4VEC_SORT_HEAP_INDEX_D_TEST'
print ' I4VEC_SORT_HEAP_INDEX_D creates a descending'
print ' sort index for an I4VEC.'
b = 0
c = 3 * n
seed = 123456789
a, seed = i4vec_uniform_ab ( n, b, c, seed )
i4vec_print ( n, a, ' Unsorted array A:' )
indx = i4vec_sort_heap_index_d ( n, a )
i4vec_print ( n, indx, ' Sort vector INDX:' )
print ''
print ' I INDX(I) A(INDX(I))'
print ''
for i in range ( 0, n ):
print ' %8d %8d %8d' % ( i, indx[i], a[indx[i]] )
#
# Terminate.
#
print ''
print 'I4VEC_SORT_HEAP_INDEX_D_TEST:'
print ' Normal end of execution.'
return
def i4vec_permute_test():
#*****************************************************************************80
#
## I4VEC_PERMUTE_TEST tests I4VEC_PERMUTE.
#
# Licensing:
#
# This code is distributed under the GNU LGPL license.
#
# Modified:
#
# 25 October 2014
#
# Author:
#
# John Burkardt
#
from i4vec_print import i4vec_print
from i4vec_uniform_ab import i4vec_uniform_ab
from perm0_uniform import perm0_uniform
n = 12
print ''
print 'I4VEC_PERMUTE_TEST'
print ' I4VEC_PERMUTE reorders an I4VEC'
print ' according to a given permutation.'
b = 0
c = n
seed = 123456789
a, seed = i4vec_uniform_ab(n, b, c, seed)
i4vec_print(n, a, ' A[*], before rearrangement:')
p, seed = perm0_uniform(n, seed)
i4vec_print(n, p, ' Permutation vector P[*]:')
a = i4vec_permute(n, p, a)
i4vec_print(n, a, ' A[P[*]]:')
#
# Terminate.
#
print ''
print 'I4VEC_PERMUTE_TEST:'
print ' Normal end of execution.'
return
def i4vec_permute_test ( ): #*****************************************************************************80 # ## I4VEC_PERMUTE_TEST tests I4VEC_PERMUTE. # # Licensing: # # This code is distributed under the GNU LGPL license. # # Modified: # # 25 October 2014 # # Author: # # John Burkardt # from i4vec_print import i4vec_print from i4vec_uniform_ab import i4vec_uniform_ab from perm0_uniform import perm0_uniform n = 12 print '' print 'I4VEC_PERMUTE_TEST' print ' I4VEC_PERMUTE reorders an I4VEC' print ' according to a given permutation.' b = 0 c = n seed = 123456789 a, seed = i4vec_uniform_ab ( n, b, c, seed ) i4vec_print ( n, a, ' A[*], before rearrangement:' ) p, seed = perm0_uniform ( n, seed ) i4vec_print ( n, p, ' Permutation vector P[*]:' ) a = i4vec_permute ( n, p, a ) i4vec_print ( n, a, ' A[P[*]]:' ) # # Terminate. # print '' print 'I4VEC_PERMUTE_TEST:' print ' Normal end of execution.' return
def i4vec_sort_heap_index_a_test ( ):
#*****************************************************************************80
#
## I4VEC_SORT_HEAP_INDEX_A_TEST tests I4VEC_SORT_HEAP_INDEX_A.
#
# Licensing:
#
# This code is distributed under the GNU LGPL license.
#
# Modified:
#
# 27 October 2014
#
# Author:
#
# John Burkardt
#
from i4vec_print import i4vec_print
from i4vec_uniform_ab import i4vec_uniform_ab
n = 20
print ''
print 'I4VEC_SORT_HEAP_INDEX_A_TEST'
print ' I4VEC_SORT_HEAP_INDEX_A creates an ascending'
print ' sort index for an I4VEC.'
b = 0
c = 3 * n
seed = 123456789
a, seed = i4vec_uniform_ab ( n, b, c, seed )
i4vec_print ( n, a, ' Unsorted array A:' )
indx = i4vec_sort_heap_index_a ( n, a )
i4vec_print ( n, indx, ' Sort vector INDX:' )
print ''
print ' I INDX(I) A(INDX(I))'
print ''
for i in range ( 0, n ):
print ' %8d %8d %8d' % ( i, indx[i], a[indx[i]] )
return
def i4vec_reverse_test ( ): #*****************************************************************************80 # ## I4VEC_REVERSE_TEST tests I4VEC_REVERSE. # # Licensing: # # This code is distributed under the GNU LGPL license. # # Modified: # # 14 April 2009 # # Author: # # John Burkardt # from i4vec_print import i4vec_print from i4vec_uniform_ab import i4vec_uniform_ab n = 10 b = 0 c = 3 * n print '' print 'I4VEC_REVERSE_TEST' print ' I4VEC_REVERSE reverses a list of integers.' seed = 123456789 a, seed = i4vec_uniform_ab ( n, b, c, seed ) i4vec_print ( n, a, ' Original vector:' ) a = i4vec_reverse ( n, a ) i4vec_print ( n, a, ' Reversed:' ) # # Terminate. # print '' print 'I4VEC_REVERSE_TEST:' print ' Normal end of execution.' return
def i4vec_product_test ( ): #*****************************************************************************80 # ## I4VEC_PRODUCT_TEST tests I4VEC_PRODUCT. # # Licensing: # # This code is distributed under the GNU LGPL license. # # Modified: # # 25 May 2015 # # Author: # # John Burkardt # from i4vec_print import i4vec_print from i4vec_uniform_ab import i4vec_uniform_ab print '' print 'I4VEC_PRODUCT_TEST' print ' I4VEC_PRODUCT computes the product of the entries in an I4VEC.' n = 10 i4_lo = - 5 i4_hi = + 5 seed = 123456789 a, seed = i4vec_uniform_ab ( n, i4_lo, i4_hi, seed ) i4vec_print ( n, a, ' Input vector:' ) value = i4vec_product ( n, a ) print '' print ' Product of entries = %d' % ( value ) # # Terminate. # print '' print 'I4VEC_PRODUCT_TEST:' print ' Normal end of execution.' return
def i4vec_sort_bubble_a_test ( ): #*****************************************************************************80 # ## I4VEC_SORT_BUBBLE_A_TEST tests I4VEC_SORT_BUBBLE_A. # # Licensing: # # This code is distributed under the GNU LGPL license. # # Modified: # # 07 May 2015 # # Author: # # John Burkardt # from i4vec_transpose_print import i4vec_transpose_print from i4vec_uniform_ab import i4vec_uniform_ab print '' print 'I4VEC_SORT_BUBBLE_A_TEST' print ' I4VEC_SORT_BUBBLE_A ascending sorts an I4VEC.' n = 20 i4_lo = 0 i4_hi = 3 * n seed = 123456789 a, seed = i4vec_uniform_ab ( n, i4_lo, i4_hi, seed ) i4vec_transpose_print ( n, a, ' Unsorted:' ) a = i4vec_sort_bubble_a ( n, a ) i4vec_transpose_print ( n, a, ' Ascending sorted:' ) # # Terminate. # print '' print 'I4VEC_SORT_BUBBLE_A_TEST:' print ' Normal end of execution.' return
def i4vec_product_test():
#*****************************************************************************80
#
## I4VEC_PRODUCT_TEST tests I4VEC_PRODUCT.
#
# Licensing:
#
# This code is distributed under the GNU LGPL license.
#
# Modified:
#
# 25 May 2015
#
# Author:
#
# John Burkardt
#
from i4vec_print import i4vec_print
from i4vec_uniform_ab import i4vec_uniform_ab
print ''
print 'I4VEC_PRODUCT_TEST'
print ' I4VEC_PRODUCT computes the product of the entries in an I4VEC.'
n = 10
i4_lo = -5
i4_hi = +5
seed = 123456789
a, seed = i4vec_uniform_ab(n, i4_lo, i4_hi, seed)
i4vec_print(n, a, ' Input vector:')
value = i4vec_product(n, a)
print ''
print ' Product of entries = %d' % (value)
#
# Terminate.
#
print ''
print 'I4VEC_PRODUCT_TEST:'
print ' Normal end of execution.'
return
def i4vec_min_test():
#*****************************************************************************80
#
## I4VEC_MIN_TEST tests I4VEC_MIN.
#
# Licensing:
#
# This code is distributed under the GNU LGPL license.
#
# Modified:
#
# 08 November 2014
#
# Author:
#
# John Burkardt
#
from i4vec_print import i4vec_print
from i4vec_uniform_ab import i4vec_uniform_ab
print ''
print 'I4VEC_MIN_TEST'
print ' I4VEC_MIN returns the minimum entry in an I4VEC.'
n = 10
a = 1
b = 30
seed = 123456789
x, seed = i4vec_uniform_ab(n, a, b, seed)
i4vec_print(n, x, ' The vector:')
x_min = i4vec_min(n, x)
print ''
print ' Minimum entry = %d' % (x_min)
#
# Terminate.
#
print ''
print 'I4VEC_MIN_TEST'
print ' Normal end of execution.'
return
def i4vec_sort_bubble_a_test():
#*****************************************************************************80
#
## I4VEC_SORT_BUBBLE_A_TEST tests I4VEC_SORT_BUBBLE_A.
#
# Licensing:
#
# This code is distributed under the GNU LGPL license.
#
# Modified:
#
# 07 May 2015
#
# Author:
#
# John Burkardt
#
from i4vec_transpose_print import i4vec_transpose_print
from i4vec_uniform_ab import i4vec_uniform_ab
print ''
print 'I4VEC_SORT_BUBBLE_A_TEST'
print ' I4VEC_SORT_BUBBLE_A ascending sorts an I4VEC.'
n = 20
i4_lo = 0
i4_hi = 3 * n
seed = 123456789
a, seed = i4vec_uniform_ab(n, i4_lo, i4_hi, seed)
i4vec_transpose_print(n, a, ' Unsorted:')
a = i4vec_sort_bubble_a(n, a)
i4vec_transpose_print(n, a, ' Ascending sorted:')
#
# Terminate.
#
print ''
print 'I4VEC_SORT_BUBBLE_A_TEST:'
print ' Normal end of execution.'
return
def i4vec_max_test ( ): #*****************************************************************************80 # ## I4VEC_MAX_TEST tests I4VEC_MAX. # # Licensing: # # This code is distributed under the GNU LGPL license. # # Modified: # # 08 November 2014 # # Author: # # John Burkardt # from i4vec_print import i4vec_print from i4vec_uniform_ab import i4vec_uniform_ab print '' print 'I4VEC_MAX_TEST' print ' I4VEC_MAX returns the maximum entry in an I4VEC.' n = 10 a = 1 b = 30 seed = 123456789 x, seed = i4vec_uniform_ab ( n, a, b, seed ) i4vec_print ( n, x, ' The vector:' ) x_max = i4vec_max ( n, x ) print '' print ' Maximum entry = %d' % ( x_max ) # # Terminate. # print '' print 'I4VEC_MAX_TEST' print ' Normal end of execution.' return
def i4vec_amax_test ( ): #*****************************************************************************80 # ## I4VEC_AMAX_TEST tests I4VEC_AMAX. # # Licensing: # # This code is distributed under the GNU LGPL license. # # Modified: # # 29 September 2014 # # Author: # # John Burkardt # from i4vec_print import i4vec_print from i4vec_uniform_ab import i4vec_uniform_ab print '' print 'I4VEC_AMAX_TEST' print ' I4VEC_AMAX computes the largest of the magnitudes of the' print ' entries of an I4VEC.' n = 10 lo = - 10 hi = 5 seed = 123456789 a, seed = i4vec_uniform_ab ( n, lo, hi, seed ) i4vec_print ( n, a, ' Vector A:' ) a_amax = i4vec_amax ( n, a ) print '' print ' Largest magnitude of entries of A = %d' % ( a_amax ) # # Terminate. # print '' print 'I4VEC_AMAX_TEST' print ' Normal end of execution.' return
def i4vec_amin_test ( ): #*****************************************************************************80 # ## I4VEC_AMIN_TEST tests I4VEC_AMIN. # # Licensing: # # This code is distributed under the GNU LGPL license. # # Modified: # # 29 September 2014 # # Author: # # John Burkardt # from i4vec_print import i4vec_print from i4vec_uniform_ab import i4vec_uniform_ab print '' print 'I4VEC_AMIN_TEST' print ' I4VEC_AMIN computes the smallest of the magnitudes of the' print ' entries of an I4VEC.' n = 10 lo = - 10 hi = 5 seed = 123456789 a, seed = i4vec_uniform_ab ( n, lo, hi, seed ) i4vec_print ( n, a, ' Vector A:' ) a_amin = i4vec_amin ( n, a ) print '' print ' Smallest magnitude of entries of A = %d' % ( a_amin ) # # Terminate. # print '' print 'I4VEC_AMIN_TEST' print ' Normal end of execution.' return
def i4vec_sum_test ( ): #*****************************************************************************80 # ## I4VEC_SUM_TEST tests I4VEC_SUM. # # Licensing: # # This code is distributed under the GNU LGPL license. # # Modified: # # 27 October 2014 # # Author: # # John Burkardt # from i4vec_print import i4vec_print from i4vec_uniform_ab import i4vec_uniform_ab print '' print 'I4VEC_SUM_TEST' print ' I4VEC_SUM sums the entries of an I4VEC.' n = 5 lo = 0 hi = 10 seed = 123456789 a, seed = i4vec_uniform_ab ( n, lo, hi, seed ) i4vec_print ( n, a, ' The vector:' ) s = i4vec_sum ( n, a ) print '' print ' The vector entries sum to %d' % ( s ) # # Terminate. # print '' print 'I4VEC_SUM_TEST:' print ' Normal end of execution.' return
def i4vec_increment_test ( ): #*****************************************************************************80 # ## I4VEC_INCREMENT_TEST tests I4VEC_INCREMENT. # # Licensing: # # This code is distributed under the GNU LGPL license. # # Modified: # # 09 January 2015 # # Author: # # John Burkardt # from i4vec_print import i4vec_print from i4vec_uniform_ab import i4vec_uniform_ab n = 4 print '' print 'I4VEC_INCREMENT_TEST' print ' I4VEC_INCREMENT increments an I4VEC.' v_lo = -5 v_hi = 10 seed = 123456789 v, seed = i4vec_uniform_ab ( n, v_lo, v_hi, seed ) i4vec_print ( n, v, ' The I4VEC:' ) v = i4vec_increment ( n, v ) i4vec_print ( n, v, ' The I4VEC after incrementing:' ) # # Terminate. # print '' print 'I4VEC_INCREMENT_TEST:' print ' Normal end of execution.' return
def sort_safe_rc_i4vec_test():
#*****************************************************************************80
#
## SORT_SAFE_RC_I4VEC_TEST tests SORT_SAFE_RC on an integer vector.
#
# Licensing:
#
# This code is distributed under the GNU LGPL license.
#
# Modified:
#
# 11 March 2015
#
# Author:
#
# John Burkardt
#
from i4vec_print import i4vec_print
from i4vec_uniform_ab import i4vec_uniform_ab
n = 20
print ''
print 'SORT_SAFE_RC_I4VEC_TEST'
print ' SORT_SAFE_RC sorts objects externally.'
print ' This function does not use persistent memory.'
#
# Generate some data to sort.
#
i4_lo = 1
i4_hi = n
seed = 123456789
a, seed = i4vec_uniform_ab(n, i4_lo, i4_hi, seed)
i4vec_print(n, a, ' Unsorted array:')
#
# Sort the data.
#
indx = 0
isgn = 0
i_save = 0
j_save = 0
k_save = 0
l_save = 0
n_save = 0
while (True):
indx, i, j, i_save, j_save, k_save, l_save, n_save = \
sort_safe_rc ( n, indx, isgn, i_save, j_save, k_save, l_save, n_save )
if (indx < 0):
isgn = 1
if (a[i - 1] <= a[j - 1]):
isgn = -1
elif (0 < indx):
k = a[i - 1]
a[i - 1] = a[j - 1]
a[j - 1] = k
else:
break
#
# Display the sorted data.
#
i4vec_print(n, a, ' Sorted array:')
print ''
print 'SORT_SAFE_RC_TEST:'
print ' Normal end of execution.'
return
def sort_safe_rc_i4vec_test ( ):
#*****************************************************************************80
#
## SORT_SAFE_RC_I4VEC_TEST tests SORT_SAFE_RC on an integer vector.
#
# Licensing:
#
# This code is distributed under the GNU LGPL license.
#
# Modified:
#
# 11 March 2015
#
# Author:
#
# John Burkardt
#
from i4vec_print import i4vec_print
from i4vec_uniform_ab import i4vec_uniform_ab
n = 20
print ''
print 'SORT_SAFE_RC_I4VEC_TEST'
print ' SORT_SAFE_RC sorts objects externally.'
print ' This function does not use persistent memory.'
#
# Generate some data to sort.
#
i4_lo = 1
i4_hi = n
seed = 123456789
a, seed = i4vec_uniform_ab ( n, i4_lo, i4_hi, seed )
i4vec_print ( n, a, ' Unsorted array:' )
#
# Sort the data.
#
indx = 0
isgn = 0
i_save = 0
j_save = 0
k_save = 0
l_save = 0
n_save = 0
while ( True ):
indx, i, j, i_save, j_save, k_save, l_save, n_save = \
sort_safe_rc ( n, indx, isgn, i_save, j_save, k_save, l_save, n_save )
if ( indx < 0 ):
isgn = 1
if ( a[i-1] <= a[j-1] ):
isgn = -1
elif ( 0 < indx ):
k = a[i-1]
a[i-1] = a[j-1]
a[j-1] = k
else:
break
#
# Display the sorted data.
#
i4vec_print ( n, a, ' Sorted array:' )
print ''
print 'SORT_SAFE_RC_TEST:'
print ' Normal end of execution.'
return
def monomial_value_test ( ):
#*****************************************************************************80
#
## MONOMIAL_VALUE_TEST tests MONOMIAL_VALUE on sets of data in various dimensions.
#
# Licensing:
#
# This code is distributed under the GNU LGPL license.
#
# Modified:
#
# 07 April 2015
#
# Author:
#
# John Burkardt
#
from i4vec_transpose_print import i4vec_transpose_print
from i4vec_uniform_ab import i4vec_uniform_ab
from monomial_value import monomial_value
from r8mat_nint import r8mat_nint
from r8mat_uniform_ab import r8mat_uniform_ab
print ''
print 'MONOMIAL_VALUE_TEST'
print ' Use monomial_value() to evaluate some monomials'
print ' in dimensions 1 through 3.'
e_min = -3
e_max = 6
n = 5
seed = 123456789
x_min = -2.0
x_max = +10.0
for m in range ( 1, 4 ):
print ''
print ' Spatial dimension M = %d' % ( m )
e, seed = i4vec_uniform_ab ( m, e_min, e_max, seed )
i4vec_transpose_print ( m, e, ' Exponents:' )
x, seed = r8mat_uniform_ab ( m, n, x_min, x_max, seed )
#
# To make checking easier, make the X values integers.
#
x = r8mat_nint ( m, n, x )
v = monomial_value ( m, n, e, x )
print ''
print ' V(X) ',
for i in range ( 0, m ):
print ' X(%d)' % ( i ),
print ''
print ''
for j in range ( 0, n ):
print '%14.6g ' % ( v[j] ),
for i in range ( 0, m ):
print '%10.4f' % ( x[i,j] ),
print ''
print ''
print 'MONOMIAL_VALUE_TEST'
print ' Normal end of execution.'
return
def monomial_value_test():
#*****************************************************************************80
#
## MONOMIAL_VALUE_TEST tests MONOMIAL_VALUE on sets of data in various dimensions.
#
# Licensing:
#
# This code is distributed under the GNU LGPL license.
#
# Modified:
#
# 07 April 2015
#
# Author:
#
# John Burkardt
#
from i4vec_transpose_print import i4vec_transpose_print
from i4vec_uniform_ab import i4vec_uniform_ab
from monomial_value import monomial_value
from r8mat_nint import r8mat_nint
from r8mat_uniform_ab import r8mat_uniform_ab
print ''
print 'MONOMIAL_VALUE_TEST'
print ' Use monomial_value() to evaluate some monomials'
print ' in dimensions 1 through 3.'
e_min = -3
e_max = 6
n = 5
seed = 123456789
x_min = -2.0
x_max = +10.0
for m in range(1, 4):
print ''
print ' Spatial dimension M = %d' % (m)
e, seed = i4vec_uniform_ab(m, e_min, e_max, seed)
i4vec_transpose_print(m, e, ' Exponents:')
x, seed = r8mat_uniform_ab(m, n, x_min, x_max, seed)
#
# To make checking easier, make the X values integers.
#
x = r8mat_nint(m, n, x)
v = monomial_value(m, n, e, x)
print ''
print ' V(X) ',
for i in range(0, m):
print ' X(%d)' % (i),
print ''
print ''
for j in range(0, n):
print '%14.6g ' % (v[j]),
for i in range(0, m):
print '%10.4f' % (x[i, j]),
print ''
print ''
print 'MONOMIAL_VALUE_TEST'
print ' Normal end of execution.'
return
