#! /usr/bin/env python3
#
def knapsack_greedy ( p, w, c ):

#*****************************************************************************80
#
## knapsack_greedy() applies a greedy algorithm to a knapsack problem.
#
#  Discussion:
#
#    It is assumed that the data has been sorted in decreasing order of P/W.
#
#  Licensing:
#
#    This code is distributed under the MIT license.
#
#  Modified:
#
#    27 October 2022
#
#  Author:
#
#    John Burkardt
#
#  Reference:
#
#    Donald Kreher, Douglas Simpson,
#    Combinatorial Algorithms,
#    CRC Press, 1998,
#    ISBN: 0-8493-3988-X,
#    LC: QA164.K73.
#
#  Input:
#
#    integer P(N), the "profit" or value of each object.
#
#    integer W(N), the "weight" or cost of each object.
#
#    integer C: the maximum weight capacity for the knapsack.
#
#  Output:
#
#    integer X(N): X(I) is 1 if object I is to be taken, 0 otherwise..
#
  import numpy as np

  n = len ( w )
  x = np.zeros ( n, dtype = np.int )
  mass = 0
  for i in range ( 0, n ):
    if ( mass + w[i] <= c ):
      x[i] = 1
      mass = mass + w[i]

  return x

def knapsack_greedy_test01 ( ):

#*****************************************************************************80
#
## knapsack_greedy_test01() tests a greedy algorithm for the knapsack problem.
#
#  Licensing:
#
#    This code is distributed under the MIT license. 
#
#  Modified:
#
#    29 October 2022
#
#  Author:
#
#    John Burkardt
#
  import numpy as np

  print ( '' )
  print ( 'knapsack_greedy_test01():' )
  print ( '  knapsack_greedy() uses a greedy algorithm to estimate a' )
  print ( '  solution of the knapsack problem.' )

  for test in range ( 0, 6 ):

    if ( test == 0 ):
      c = 26
      n = 5
      p = np.array ( [  24,  13,  23,  15,  16 ] )
      w = np.array ( [  12,   7,  11,   8,   9 ] )
    elif ( test == 1 ):
      c = 190
      n = 6
      p = np.array ( [  50,  50,  64,  46,  50,   5 ] )
      w = np.array ( [  56,  59,  80,  64,  75,  17 ] )
    elif ( test == 1 ):
      c = 50
      n = 7
      p = np.array ( [  70,  20,  39,  37,   7,   5,  10 ] )
      w = np.array ( [  31,  10,  20,  19,   4,   3,   6 ] )
    elif ( test == 2 ):
      c = 104
      n = 8
      p = np.array ( [ 350, 400, 450,  20,  70,   8,   5,   5 ] )
      w = np.array ( [  25,  35,  45,   5,  25,   3,   2,   2 ] )
    elif ( test == 4 ):
      c = 67
      n = 10
      p = np.array ( [ 505, 352, 458, 220, 354, 414, 498, 545, 473, 543 ] )
      w = np.array ( [  23,  26,  20,  18,  32,  27,  29,  26,  30,  27 ] )
    elif ( test == 5 ):
      c = 165
      n = 10
      p = np.array ( [  92,  57,  49,  68,  60,  43,  67,  84,  87,  72 ] )
      w = np.array ( [  23,  31,  29,  44,  53,  38,  63,  85,  89,  82 ] )

    print ( '' )
    print ( '  Test', test )
    print ( '    Knapsack weight capacity is', c )
    print ( '    Object weights:' )
    print ( w )
    print ( '    Object values:' )
    print ( p )

    p, w = knapsack_reorder ( p, w )

    print ( '' )
    print ( '  Object  Profit    Mass    P/M' )
    print ( '' )
    for i in range ( 0, n ):
      print ( '  %6d  %6d  %6d  %g' % ( i, p[i], w[i], p[i] / w[i] ) )

    x = knapsack_greedy ( p, w, c )

    print ( '' )
    print ( '  Contents of Knapsack' )
    print ( '  Object  Profit    Mass    P/M' )
    print ( '' )

    chosen = 0
    mass = 0
    profit = 0
    for i in range ( 0, n ):
      if ( x[i] == 1 ):
        chosen = chosen + 1
        mass = mass + w[i]
        profit = profit + p[i]
        print ( '  %6d  %6d  %6d  %g' % ( i, p[i], w[i], p[i] / w[i] ) )
    print ( '' )
    print ( '  Number of objects chosen =', chosen )
    print ( '  Total weight of chosen objects =', mass )
    print ( '  Total profit of chosen objects =', profit )

  return

def knapsack_greedy_test ( ):

#*****************************************************************************80
#
## knapsack_greedy_test() tests knapsack_greedy().
#
#  Licensing:
#
#    This code is distributed under the MIT license.
#
#  Modified:
#
#    27 October 2022
#
#  Author:
#
#    John Burkardt
#
  import numpy as np
  import platform

  print ( '' )
  print ( 'knapsack_greedy_test():' )
  print ( '  python version: ' + platform.python_version ( ) )
  print ( '  numpy version:  ' + np.version.version )
  print ( '  Test knapsack_greedy().' )

  knapsack_greedy_test01 ( )
#
#  Terminate.
#
  print ( '' )
  print ( 'knapsack_greedy_test():' )
  print ( '  Normal end of execution.' )

  return

def knapsack_reorder ( p, w ):

#*****************************************************************************80
#
## knapsack_reorder() reorders knapsack data by "profit density".
#
#  Discussion:
#
#    This routine must be called to rearrange the data before calling
#    routines that handle a knapsack problem.
#
#    The "profit density" for object I is defined as P(I)/W(I).
#
#  Licensing:
#
#    This code is distributed under the MIT license.
#
#  Modified:
#
#    27 October 2022
#
#  Author:
#
#    John Burkardt
#
#  Reference:
#
#    Donald Kreher, Douglas Simpson,
#    Combinatorial Algorithms,
#    CRC Press, 1998,
#    ISBN: 0-8493-3988-X,
#    LC: QA164.K73.
#
#  Input:
#
#    integer P(N), the "profit" or value of each object.
#
#    integer W(N), the "weight" or cost of each object.
#
#  Output:
#
#    integer P2(N), the reordered "profit" or value of each object.
#
#    integer W2(N), the reordered "weight" or cost of each object.
#
  import numpy as np

  pw = p / w
  index = np.argsort ( pw )
  index = np.flip ( index )

  w2 = w[index]
  p2 = p[index]

  return p2, w2

def timestamp ( ):

#*****************************************************************************80
#
## timestamp() prints the date as a timestamp.
#
#  Licensing:
#
#    This code is distributed under the MIT license. 
#
#  Modified:
#
#    06 April 2013
#
#  Author:
#
#    John Burkardt
#
  import time

  t = time.time ( )
  print ( time.ctime ( t ) )

  return None

if ( __name__ == '__main__' ):
  timestamp ( )
  knapsack_greedy_test ( )
  timestamp ( )