




from random import shuffle

import tensorflow as tf
from numpy import array

def       _SCREAMING_SNAKE_CASE      (							lowercase     :	Tuple     ,							lowercase     :	int					):


      '''simple docstring'''



      lowerCamelCase_							=   int(lowercase					)
      assert noofclusters < len(lowercase					)

      # Find out the dimensionality
      lowerCamelCase_							=   len(vectors[0]					)

      # Will help select random centroids from among the available vectors
      lowerCamelCase_							=   list(range(len(lowercase					)					)					)
      shuffle(lowercase					)

      # GRAPH OF COMPUTATION
      # We initialize a new graph and set it as the default during each run
      # of this algorithm. This ensures that as this function is called
      # multiple times, the default graph doesn't keep getting crowded with
      # unused ops and Variables from previous function calls.

      lowerCamelCase_							=   tf.Graph()

      with graph.as_default():
            # SESSION OF COMPUTATION

            lowerCamelCase_							=   tf.Session()

            ##CONSTRUCTING THE ELEMENTS OF COMPUTATION

            ##First lets ensure we have a Variable vector for each centroid,
            ##initialized to one of the vectors from the available data points
            lowerCamelCase_							=   [
                tf.Variable(vectors[vector_indices[i]]					) for i in range(lowercase					)
            ]
            ##These nodes will assign the centroid Variables the appropriate
            ##values
            lowerCamelCase_							=   tf.placeholder('float64'     ,							[dim]					)
            lowerCamelCase_							=   []
            for centroid in centroids:
                  cent_assigns.append(tf.assign(lowercase     ,							lowercase					)					)

            ##Variables for cluster assignments of individual vectors(initialized
            ##to 0 at first)
            lowerCamelCase_							=   [tf.Variable(0					) for i in range(len(lowercase					)					)]
            ##These nodes will assign an assignment Variable the appropriate
            ##value
            lowerCamelCase_							=   tf.placeholder('int32'					)
            lowerCamelCase_							=   []
            for assignment in assignments:
                  cluster_assigns.append(tf.assign(lowercase     ,							lowercase					)					)

            ##Now lets construct the node that will compute the mean
            # The placeholder for the input
            lowerCamelCase_							=   tf.placeholder('float'     ,							[None, dim]					)
            # The Node/op takes the input and computes a mean along the 0th
            # dimension, i.e. the list of input vectors
            lowerCamelCase_							=   tf.reduce_mean(lowercase     ,							0					)

            ##Node for computing Euclidean distances
            # Placeholders for input
            lowerCamelCase_							=   tf.placeholder('float'     ,							[dim]					)
            lowerCamelCase_							=   tf.placeholder('float'     ,							[dim]					)
            lowerCamelCase_							=   tf.sqrt(tf.reduce_sum(tf.pow(tf.sub(lowercase     ,							lowercase					)     ,							2					)					)					)

            ##This node will figure out which cluster to assign a vector to,
            ##based on Euclidean distances of the vector from the centroids.
            # Placeholder for input
            lowerCamelCase_							=   tf.placeholder('float'     ,							[noofclusters]					)
            lowerCamelCase_							=   tf.argmin(lowercase     ,							0					)

            ##INITIALIZING STATE VARIABLES

            ##This will help initialization of all Variables defined with respect
            ##to the graph. The Variable-initializer should be defined after
            ##all the Variables have been constructed, so that each of them
            ##will be included in the initialization.
            lowerCamelCase_							=   tf.initialize_all_variables()

            # Initialize all variables
            sess.run(lowercase					)

            ##CLUSTERING ITERATIONS

            # Now perform the Expectation-Maximization steps of K-Means clustering
            # iterations. To keep things simple, we will only do a set number of
            # iterations, instead of using a Stopping Criterion.
            lowerCamelCase_							=   1_00
            for _ in range(lowercase					):
                  ##EXPECTATION STEP
                  ##Based on the centroid locations till last iteration, compute
                  ##the _expected_ centroid assignments.
                  # Iterate over each vector
                  for vector_n in range(len(lowercase					)					):
                        lowerCamelCase_							=   vectors[vector_n]
                        # Compute Euclidean distance between this vector and each
                        # centroid. Remember that this list cannot be named
                        #'centroid_distances', since that is the input to the
                        # cluster assignment node.
                        lowerCamelCase_							=   [
                            sess.run(lowercase     ,							feed_dict={va: vect, va: sess.run(lowercase					)}					)
                            for centroid in centroids
                        ]
                        # Now use the cluster assignment node, with the distances
                        # as the input
                        lowerCamelCase_							=   sess.run(
                            lowercase     ,							feed_dict={centroid_distances: distances}					)
                        # Now assign the value to the appropriate state variable
                        sess.run(
                            cluster_assigns[vector_n]     ,							feed_dict={assignment_value: assignment}					)

                  ##MAXIMIZATION STEP
                  # Based on the expected state computed from the Expectation Step,
                  # compute the locations of the centroids so as to maximize the
                  # overall objective of minimizing within-cluster Sum-of-Squares
                  for cluster_n in range(lowercase					):
                        # Collect all the vectors assigned to this cluster
                        lowerCamelCase_							=   [
                            vectors[i]
                            for i in range(len(lowercase					)					)
                            if sess.run(assignments[i]					) == cluster_n
                        ]
                        # Compute new centroid location
                        lowerCamelCase_							=   sess.run(
                            lowercase     ,							feed_dict={mean_input: array(lowercase					)}					)
                        # Assign value to appropriate variable
                        sess.run(
                            cent_assigns[cluster_n]     ,							feed_dict={centroid_value: new_location}					)

        # Return centroids and assignments
            lowerCamelCase_							=   sess.run(lowercase					)
            lowerCamelCase_							=   sess.run(lowercase					)
            return centroids, assignments









import math

def       _SCREAMING_SNAKE_CASE      (							lowercase     :	int					):


      '''simple docstring'''



      lowerCamelCase_							=   0
      lowerCamelCase_							=   0
      while num > 0:
            lowerCamelCase_							=   num % 8
            lowerCamelCase_							=   octal + (remainder * math.floor(math.pow(10     ,							lowercase					)					))
            counter += 1
            lowerCamelCase_							=   math.floor(num / 8					)  # basically /= 8 without remainder if any
            # This formatting removes trailing '.0' from `octal`.
      return f"""0o{int(lowercase					)}"""

def       _SCREAMING_SNAKE_CASE      (							):


      '''simple docstring'''



      print('\n2 in octal is:'					)
      print(decimal_to_octal(2					)					)  # = 2
      print('\n8 in octal is:'					)
      print(decimal_to_octal(8					)					)  # = 10
      print('\n65 in octal is:'					)
      print(decimal_to_octal(65					)					)  # = 101
      print('\n216 in octal is:'					)
      print(decimal_to_octal(2_16					)					)  # = 330
      print('\n512 in octal is:'					)
      print(decimal_to_octal(5_12					)					)  # = 1000
      print('\n'					)


if __name__ == "__main__":
 main()



