compilation error

[gamask]

This code doesn't compile, and I don't know what the error message means.

There's a line with a comment "THIS ONE". If we replace ar[0] with 123 in that line then it works fine.
Alternatively we can remove all the code in SECTION 1 or SECTION 7, and then it'll work.

import math
import numpy



input_order = [
    'nym', 'nf',
    'ebci', 'ebui', 'bbi', 'eaci', 'eaui', 'bai', 'egc', 'egu', 'bg', 'edc', 'edu', 'bi', 'edgc', 'edgu', 'erc', 'eru', 'br', 'chu', 'af', 'lp', 'ly',
    'acti',
    
    's'
]

input_indices = dict([(k,i) for i,k in enumerate(input_order)])


def get_index (acti, acc, cnum):
    for item in acti:
        if item[0] == acc and item[1] == cnum:
            return item[2]
    return None


#pythran export n_steps
n_steps = 9

#pythran export n_state_vars
n_state_vars = 12

#pythran export cache_indices
cache_indices = {
    'ec'        : 0,
    'eu'        : 1,
    'b'         : 2,
    'cgc'       : 3,
    'cgu'       : 4,
    'cgb'       : 5,
    'c'         : 6,
    'poc'       : 7,
    'ed'        : 8,
    'ta'        : 9,
    'rdwa'      : 10,
    'max_rdwa'  : 11,
}


#pythran export set_cache (
#   float64 [], int, int, float64 [][][][][][] order(C),
#   (
#       int, int,
#       float64 [], float64 [], float64 [], float64 [], float64 [], float64 [], float64 [][] order(C), float64 [][] order(C), float64 [][] order(C), float64 [][] order(C), float64 [][] order(C), float64 [][] order(C), float64 [][] order(C), float64 [][] order(C), float64 [][] order(C), float64 [][] order(C), float64 [][] order(C), float64 [], float64 [], float64 [], float64 [],
#       (str, int, int) list,
#       
#       float64
#   )
#)
def set_cache (x, cnum, cache_index, cache, inputs):
    nym     = inputs[input_indices['nym']]
    nf      = inputs[input_indices['nf']]
    acti    = inputs[input_indices['acti']]
    s       = inputs[input_indices['s']]
    
    index = get_index (acti, 'a', cnum)
    #if index is None:
        #return
    
    ebci    = inputs[input_indices['ebci']][cnum]
    ebui    = inputs[input_indices['ebui']][cnum]
    bbi     = inputs[input_indices['bbi']][cnum]
    eaci    = inputs[input_indices['eaci']][cnum]
    eaui    = inputs[input_indices['eaui']][cnum]
    bai     = inputs[input_indices['bai']][cnum]
    egc     = inputs[input_indices['egc']][cnum] / 100.
    egu     = inputs[input_indices['egu']][cnum] / 100.
    bg      = inputs[input_indices['bg']][cnum] / 100.
    edc     = inputs[input_indices['edc']][cnum] / 100.
    edu     = inputs[input_indices['edu']][cnum] / 100.
    bi      = inputs[input_indices['bi']][cnum] / 100.
    edgc    = inputs[input_indices['edgc']][cnum] / 100.
    edgu    = inputs[input_indices['edgu']][cnum] / 100.
    erc     = inputs[input_indices['erc']][cnum] / 100.
    eru     = inputs[input_indices['eru']][cnum] / 100.
    br      = inputs[input_indices['br']][cnum] / 100.
    chu     = inputs[input_indices['chu']][cnum] / 100.
    af      = inputs[input_indices['af']][cnum] / 100.
    lp      = inputs[input_indices['lp']][cnum]
    ly      = inputs[input_indices['ly']][cnum]
    
    tbi = ebci + ebui + bbi
    
    if tbi != 0:
        ecf = ebci / tbi
        euf = ebui / tbi
        bf = bbi / tbi
    else:
        #iec = egc != 0 or edc != 0 or edgc != 0
        #ieu = egu != 0 or edu != 0 or edgu != 0
        #ib = bg != 0 or bi != 0
        iec = False
        ieu = False
        ib = False
        if egc != 0 or edc != 0 or edgc != 0:
            iec = True
        if egu != 0 or edu != 0 or edgu != 0:
            ieu = True
        if bg != 0 or bi != 0:
            ib = True
        
        ni = [iec, ieu, ib].count(True)
        
        if ni == 0:
            ecf = 1
            euf = 0
            bf = 0
        else:
            ecf = 1 / ni
            euf = 1 / ni
            bf = 1 / ni
    
    # ---------------------------------------
    
    def f1 (ats, which, c, ta, ebc, ebu, b, cgc, cgu, cgb):
        if which == 'c':
            ba = ebc
            cg = cgc
        elif which == 'u':
            ba = ebu
            cg = cgu
        elif which == 'b':
            ba = b
            cg = cgb
        else:
            raise Exception('which = %s' % (str(which)))
            
        fs = ats / ba
        
        tag = min(cg * fs, 10 * s) * 0.2 + max(cg * fs - 10 * s, 0) * 0.35
        
        c_delta = ats
        c += ats
        ta += tag
        if which == 'c':
            ebc -= ats
            cgc *= (1 - fs)
        elif which == 'u':
            ebu -= ats
            cgu *= (1 - fs)
        elif which == 'b':
            b -= ats
            cgb *= (1 - fs)
        else:
            raise Exception('which = %s' % (str(which)))
        
        return c_delta, c, ta, ebc, ebu, b, cgc, cgu, cgb
    
    # ---------------------------------------
    
    if cache_index >= 2:
        ny_min = cache_index
    else:
        ny_min = 0
    
    if ny_min != 0:
        for ny in range(0, ny_min):
            cache[cache_index,ny,cnum,:,:,:] = cache[0,ny,cnum,:,:,:]
    
    
    for ny in range(ny_min, nym + 1):
        if ny != 0:
            y = ny - 1
        else:
            y = 0
        
        
        if ny == 0:
            ebc = ebci
            ebu = ebui
            b   = bbi
            cgc = ebc - eaci
            cgu = ebu - eaui
            cgb = b - bai
        else:
            ebc = cache[cache_index][ny - 1][cnum][0][n_steps - 1][cache_indices['ec']]
            ebu = cache[cache_index][ny - 1][cnum][0][n_steps - 1][cache_indices['eu']]
            b   = cache[cache_index][ny - 1][cnum][0][n_steps - 1][cache_indices['b']]
            cgc = cache[cache_index][ny - 1][cnum][0][n_steps - 1][cache_indices['cgc']]
            cgu = cache[cache_index][ny - 1][cnum][0][n_steps - 1][cache_indices['cgu']]
            cgb = cache[cache_index][ny - 1][cnum][0][n_steps - 1][cache_indices['cgb']]
        
        # ----------------
        
        for j in range(2):
            c = 0.
            poc = 0.
            ed = 0.
            ta = 0.
            if j == 0:
                max_rdwa = 0.
            
            
            if ny == 0 or j == 1:
                rdwa = 0.
            else:
                rdwa = x[index + y * nf]
            
            
            if j == 1:
                li = True
            else:
                li = False
            
            
            if j == 0:
                tbjls = ebc + ebu + b
            
            # -------------------
            
            step = 0
            
            # [SECTION 1 START]
            if ny != 0 and j == 0:
                # 1.
                
                step += 1
                
                if ebc > 0:
                    delta = ebc * egc[y]
                    ebc += delta
                    cgc += delta
                
                if ebu > 0:
                    delta = ebu * egu[y]
                    ebu += delta
                    cgu += delta
                
                if b > 0:
                    delta = b * bg[y]
                    b += delta
                    cgb += delta
                
                cache[cache_index][ny][cnum][j][step - 1][:] = [ebc, ebu, b, cgc, cgu, cgb, c, poc, ed, ta, rdwa, max_rdwa]
            # [SECTION 1 END]
                
                # ---------
            
            # [SECTION 7 START]
            # 7.
            
            step += 1
            
            if rdwa > 0 and not li:
                delta = min(rdwa, c)
                rdwa -= delta
                c -= delta
                poc += delta
                
            cache[cache_index][ny][cnum][j][step - 1][:] = [ebc, ebu, b, cgc, cgu, cgb, c, poc, ed, ta, rdwa, max_rdwa]
            # [SECTION 7 END]
            
            # ---------
            
            # 8.
            
            step += 1
            
            if j == 0 and rdwa < -0.001 * s:
                c += abs(rdwa)
                rdwa = 0.
                
                ebc += c * ecf
                ebu += c * euf
                b += c * bf
                c = 0.
            else:
                if j == 0:
                    n = 3
                    o = [ebci, ebui, bbi]
                    cu = [ebc, ebu, b]
                    ai = [i for i,val in enumerate(cu) if val != 0]
                    total_o = sum([o[i] if i in ai else 0. for i in range(n)])
                    fo = [o[i] / total_o if i in ai else 0. for i in range(n)]
                    
                    t = []
                    for i in range(n):
                        if i not in ai:
                            t.append([])
                        else:
                            t.append(
                                [cu[i] * fo[j] / fo[i] for j in range(n)]
                            )
                    fi = []
                    for i in range(n):
                        if len(t[i]) != 0 and all([
                            t[i][j] <= cu[j] + 0.001 * s
                            for j in range(n)
                        ]):
                            fi.append(i)
                    
                    ri = [i for i in range(n) if i not in fi]
                    
                    mr = [cu[i] - t[fi[0]][i] if i in ri else 0 for i in range(n)]
                    smr = sum(mr)
                    if rdwa < smr:
                        ar = [mr[i] * rdwa / smr for i in range(n)]
                    else:
                        ar = [mr[i] + (rdwa - smr) * fo[i] for i in range(n)]
                else:
                    ar = [ebc, ebu, b]
                
                #delta, c_, ta_, ebc_, ebu_, b_, cgc_, cgu_, cgb_ = f1 (123, 'c', c, ta, ebc, ebu, b, cgc, cgu, cgb)
                delta, c_, ta_, ebc_, ebu_, b_, cgc_, cgu_, cgb_ = f1 (ar[0], 'c', c, ta, ebc, ebu, b, cgc, cgu, cgb)       # [THIS ONE]
                c = c_ + 0.; ta = ta_ + 0.; ebc = ebc_ + 0.; ebu = ebu_ + 0.; b = b_ + 0.; cgc = cgc_ + 0.; cgu = cgu_ + 0.; cgb = cgb_ + 0.
                c -= delta
                poc += delta
                rdwa -= delta
                max_rdwa += delta
            
            cache[cache_index][ny][cnum][j][step - 1][:] = [ebc, ebu, b, cgc, cgu, cgb, c, poc, ed, ta, rdwa, max_rdwa]
            
            # ---------
            
            # 9.
            
            step += 1
            
            if j == 0:
                ta -= tbjls * af
                if ny <= ly:
                    ta -= lp
                ta = max(ta, 0.)
            
            max_rdwa = max(0., max_rdwa)
            cache[cache_index][ny][cnum][j][step - 1][:] = [ebc, ebu, b, cgc, cgu, cgb, c, poc, ed, ta, rdwa, max_rdwa]

[serge-sans-paille]

The code compiles file when setting export CXX=clang++ or passing --config compiler.cxx=clang++. Can you confirm?

[gamask]

Still get the same error.

/home/alex/.local/lib/python3.10/site-packages/pythran/pythonic/types/list.hpp:546:12: error: no matching member function for call to 'push_back'

I got clang 14. Are you using a later version?