Changeset 1195 in lmdz_wrf for trunk/tools

Timestamp:

Oct 18, 2016, 3:53:08 PM (8 years ago)

Author:

lfita

Message:

Adding:

• `list_combos': Function to construct a new list with all possible N-combinations of the list-values
• `prime_decomposition': Function to decompose a given number with its multiple prime numbers
• `prime_numbers': Function to find all the prime numbers up to a given value above 17
• `timestep_conform': Function to provide the time-step in seconds which conforms 1 temporal unit and the resultant number of time-steps for a whole period is multiple of a given number

File:

• trunk/tools/generic_tools.py (modified) (6 diffs)

trunk/tools/generic_tools.py

@@ -62 +62 @@
 # list_coincidences: Function to provide the coincidences between two lists
 # list_differences: Function to provide the differences between two lists
+# list_norepeatcombos: Function to all possible (Num-1)-combinations of a Num values without repetitions
 # multi_index_mat: Function to provide the multiple coordinates of a given value inside a matrix
 # num_chainSnum: Function to pass a value to a `ChainStrNum' number
@@ -69 +70 @@
 #  [YYYY][MM][DD][HH][MI][SS] format) in a 360 years calendar
 # pretty_int: Function to plot nice intervals
+# prime_decomposition: Function to decompose a given number with its multiple prime numbers
+# prime_numbers: Function to find all the prime numbers up to a given value above 17
 # printing_dictionary: Function to print the content of a dictionary
 # PolyArea: Function to compute the area of the polygon following 'Shoelace formula'
@@ -85 +88 @@
 # stringList_dictKeysVals: Function to provide a dictionary with keys which contain values of lists from a string
 # subbasin_point: Function to provide sub-basins given a grid point following a matrix of trips
+# timestep_conform: Function to provide the time-step in seconds which conforms 1 temporal unit and the resultant number
+#   of time-steps for a whole period is multiple of a given number
 # unitsdsDate: Function to know how many units of time are from a given pair of dates
 # vals_around: Function to provide the 3x3 values around a given j,i point
@@ -292 +297 @@
 
     return newlist
+
+def list_norepeatcombos(Num):
+    """ Function to all possible (Num-1)-combinations of a Num values without repetitions
+      Num= number of elements
+    >>> list_norepeatcombos(4)
+    [[0, 1], [0, 2], [0, 3], [1, 2], [1, 3], [2, 3], [0, 1, 2], [0, 1, 3], [0, 2, 3], [1, 2, 3]]
+    """
+    from math import factorial
+    fname = 'list_norepeatcombos'
+
+    listv = range(Num)
+
+    samevals = []
+    diffvals = []
+    for iv in listv:
+        if not searchInlist(diffvals,iv): diffvals.append(iv)
+        if searchInlist(samevals,iv): samevals.append(iv)
+
+    combos = []
+    Nlvs = len(listv)
+    # Number of possible combinations
+    for ic in range(2,Nlvs):
+        Ncombs = factorial(Nlvs)/(factorial(ic)*factorial(Nlvs-ic))
+        combo = range(ic)
+        # Getting the limits for each element of the combination of ic-elements
+        limitcombo = range(ic)
+        for icc in range(ic):
+            limitcombo[icc] = Nlvs-ic+icc
+      
+        combos.append(combo)
+        ncombo = list(combo)
+        for ico in range(Ncombs):
+           # Incrementing the last coordinate
+            ncombo[ic-1] = ncombo[ic-1] + 1
+            if ncombo[ic-1] > limitcombo[ic-1]:
+                # looping all over the others if there is an overpass of the value
+                #   previous coordinate will be incremented and the following ones 
+                #   will be incremented by 1 starting from the new assigned previous 
+                #   value
+                for icc in range(1,ic):
+                    # Incrementing the previous one
+                    ncombo[ic-icc-1] = ncombo[ic-icc-1]+1
+                    # Incrementing the following ones since the value at the previous 
+                    #   position
+                    for iccc in range(ic-icc,ic):
+                        ncombo[iccc] = ncombo[iccc-1]+1
+                    if ncombo[ic-icc-1] <= limitcombo[ic-icc-1]: 
+                        combos.append(list(ncombo))
+                        break
+            else:
+                combos.append(list(ncombo))
+
+    return combos
 
 def datetimeStr_conversion(StringDT,typeSi,typeSo):
@@ -9511 +9569 @@
     return newlist 
 
-
 def pretty_int(minv,maxv,Nint):
     """ Function to plot nice intervals
@@ -9569 +9626 @@
     return np.array(values, dtype=np.float)
 
+def prime_numbers(value):
+    """ Function to find all the prime numbers up to a given value above 17
+      value: limiting value to use
+    >>> primes(100)
+    [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]
+    """
+    fname = 'prime_numbers'
+
+    primes = [2,3,5,7,11,13,17]
+    lastprime = 17
+    for i in range(lastprime+1,value):
+        #print '  ',i,value
+        isprime = False
+        for ip in primes:
+            # No need to find allover the previous primes, just as big as the half
+            if ip < i/2:
+                if np.mod(i,ip) == 0:
+                    isprime = False
+                    break
+                else:
+                    isprime = True
+        if isprime:
+            primes.append(i)
+            lastprime = i
+            #print fname + ': prime number',i,'!!'
+    return primes
+
+def prime_decomposition(num):
+    """ Function to decompose a given number with its multiple prime numbers
+      fname= num
+    >>> prime_decomposition(100)
+    {2: 2, 5: 2}
+    """
+    fname = 'prime_decomposition'
+
+    decomposition = {}
+
+    # Prime numbers
+    primnums = prime_numbers(num)
+
+    inum = num
+    while inum > primnums[0]:
+        for primn in primnums:
+            if np.mod(inum,primn) == 0:
+                inum = inum / primn
+                if decomposition.has_key(primn):
+                    decomposition[primn] = decomposition[primn] + 1
+                else:
+                    decomposition[primn] = 1
+                break
+
+    return decomposition
+
+def timestep_conform(TOTtime,tunit,multnum):
+    """ Function to provide the time-step in seconds which conforms 1 temporal unit and the resultant number of time-steps for
+     a whole period is multiple of a given number
+      TOTtime: period [seconds]
+      tunit: temporal unit at which the time-step has to conform [seconds]
+      multnum: number to which the resultant number of time-step for `TOTtime' have to be multiple
+    >>> timestep_conform(86400,3600,5)
+    [4, 6, 8, 9, 10, 12, 15, 16, 18, 20, 24, 30, 36, 40, 45, 48, 60, 72, 80, 90, 120, 144, 180, 240, 360, 720]
+    """
+    fname = 'timestep_conform'
+
+    # Possible fractions
+    tunitdecompos = prime_decomposition(tunit)
+
+    allvals = []
+    for prime in tunitdecompos.keys():
+        for it in range(tunitdecompos[prime]):
+            allvals.append(prime)
+
+    Nallvals = len(allvals)
+    allcombinations = list_norepeatcombos(Nallvals)
+    Ncombos = len(allcombinations)
+    
+    # It might be a far more efficient way? I'm lazy...
+    timestep = []
+    for ic in range(Ncombos):
+        combo = allcombinations[ic]
+        val = 1
+        for icc in combo:
+            val = val*allvals[icc]
+
+        if not searchInlist(timestep,val) and np.mod(TOTtime/val,multnum) == 0: 
+            timestep.append(val)
+
+    timestep.sort()
+    return timestep
+
+print timestep_conform(86400,3600,5)
 #quit()