Multiplicación en listas

[Ania_]

Hola a todos:

Lo que quiero hacer es muy simple, a esta lista de listas

coeffs=[[1,1,1,2,1],[7,0,3,-4,3],[11,-6,0,3,-3]], le quiero multiplicar una lista que se crea aleatoriamente con 0 y 1, pero esta lista tiene solo 5 posiciones
ej:[[0], [0], [0], [0], [1]], lo que debo lograr es que esta lista multiplique a cada posición i de la lista coeffs.

coeffs[i][j] -> i=1...3 j=1...5 , no sé si queda claro

de todas maneras aqui va lo que estoy intentando

Código Python:

def crea_sol_inicial():
    vs=[]
    from random import randint    
    for i in range(size):
        vs.append([randint(0,100)%2])
    
    val=[]
    for i in range(csize):
        for j in range(size):
            aux=coeffs[i][j]*vs[j]
            val.append(aux)
    print val
 

El resultado de val es asqueroso...y en fin no es lo que quiero, un resultado valido seria que se formara una lista parecida a coeffs, lo unico q seria 0 y 1
Ej: val=[[1,1,0,0,0],[1,0,1,0,1],[1,1,0,1,0]], luego el paso a seguir es sumar todos esos 0 y 1 que me quedo en la lista y que fuera un solo valor, en ese caso seria 8.

El codigo en C esta escrito de esta manera, a lo mejor con eso entienden mejor

Código C:

/* Verifica factibilidad */
int evalFactibility(int* vs) {
for (int i = 0; i < CSIZE; i++) {
    int val = 0;
    for (int j = 0; j < SIZE; j++) {
        val += coeffs[i][j] * vs[j];
    }
 
 
}
 
int* getRandomString() {
int* vs = new int[SIZE];
 
vs[0] = 0;
vs[1] = 0;
vs[2] = 1;
vs[3] = 1;
vs[4] = 0;
srand((unsigned)time( NULL ) ); 
do {
   for (int i = 0; i < SIZE; i++) {
       vs[i] = rand()%2;
   }
} while(!evalFactibility(vs));
return vs;
}
 

[razpeitia]

No se muy bien lo que quieras hacer apesar del codigo que das en C++ y Python:
Entiendo algunas partes, pero otras no concuerda lo que quieres hacer en python y lo que haces en C++

A los 2 códigos les faltan cosas, solo para aclarar.

Lo que haces es:
1.- Tienes una lista de listas que contienen los coeficientes de X cosa.
2.- Generas una lista de 0's y 1's de manera aleatoria.
3.- Haces la suma de los, coeficientes multiplicados por la lista generada en el paso anterior ???
4.- Regresas una lista con la suma de los valores. ???

Los pasos 3 y 4 son diferentes en C++ y Python. Por eso no se lo quieres.

[Ania_]

Bueno, ocurre que lo q estoy haciendo es traspasar el codigo en C++ a Python

De todas maneras despues de cabecear harto, he logrado hacer algunas cosas mas...lo que te he dado son partes de codigo y a lo mejor falta informacion, lo que necesito es lo siguiente:
Tengo 2 listas
a=[3,2,-5,-2,3]
b=[[1,1,1,2,1],[7,0,3,-4,3],[11,-6,0,3,-3]]

y debo multiplicarlas por otra lista que para este ejemplo será:
c=[0,1,0,1,0]
Para la multiplicacion de a con b, tengo el siguiente codigo:

Código Python:

a=[3,2,-5,-2,3]
b=[[1,1,1,2,1],[7,0,3,-4,3],[11,-6,0,3,-3]]
c=[0,1,0,1,0]
size=5
csize=3
 
def sumar(x,y):
    return x+y
 
def funcion1():
    aux=[0]*size
    for i in range(size):
        aux[i]=a[i]*c[i]
    aux2=reduce(sumar,aux)
    print aux
    print aux2
 
funcion1()
 

El resultado de la nueva lista=[0, 2, 0, -2, 0] y la suma de todos sus indices es 0

Ahora para la multiplicación de b con c, tengo problemas, ya que es una lista de listas, si bien la multiplicacion me resulta al sumar no sé como hacerlo, porque debo sumar el primer indice de la lista q es una lista y esa me arroja un resultado, luego con la siguiente y asi sucesivamente
tengo esto:

Código Python:

a=[3,2,-5,-2,3]
b=[[1,1,1,2,1],[7,0,3,-4,3],[11,-6,0,3,-3]]
c=[0,1,0,1,0]
size=5
csize=3
def sumar(x,y):
    return x+y
def funcion2():
    
    
    val=[[0]*size for i in range(csize)]
    aux=[]
    for i in range(csize):
        for j in range(size):
            val[i][j]=b[i][j]*c[j]
            aux.append(val[i][j])
            aux2=reduce(sumar,aux)
        print aux2
 
    print val    
            
            
funcion2()
 

Lo que me tira es la lista val=[[0, 1, 0, 2, 0], [0, 0, 0, -4, 0], [0, -6, 0, 3, 0]]
y los valores 3,-1,-4 , pero lo que realmente debe salir es 3,-4,-3, obviamente el procedimiento q estoy haciendo esta malo, porque esta sumando toda la lista, lo mismo que hace en la primera funcion, el problema es q no sé como hacer

Espero q ahora haya quedado más claro :S

[razpeitia]

Aquí esta tu código corregido

Código Python:

def function2():
    val = [[0]*size for i in range(csize)]
    for i in range(csize):
        aux = [] #Esto estaba mal
        for j in range(size):
            val[i][j] = b[i][j] * c[j]
            aux.append(val[i][j])
        aux2=sum(aux) #Lo tenias dentro del for j, cuando debería estar afuera
        print aux2
    print val
 

Edito: Veo que tienes un buen "Pythonic level" sigue asi.

Aquí esta tu código, pero mejorado:

Código Python:

def fun1(l1, l2):
    #Asumo que l1 y l2 son de la misma longitud
    size = len(l1)
    aux = [l1[i] * l2[i] for i in xrange(size)]
    return sum(aux), aux
 
def fun2(l1, l2):
    #l1 es la lista de listas y l2 es c
    vals = [fun1(i, l2) for i in l1]
    print vals
 
a = [3, 2, -5, -2, 3]
b = [[1, 1, 1, 2, 1], [7, 0, 3, -4, 3], [11, -6, 0, 3, -3]]
c = [0, 1, 0, 1, 0]
fun2(b, c)
 

Veo que tienes un buen "Pythonic level" sigue asi

[Ania_]

Gracias, me sirvio de mucho...ese cumplido fue para mi??...

Ahora me encuentro con otro problemita, estoy a punto de terminar este codigo, pero me tope con un do-while en C++
Por lo que he investigando, Python no tiene ese bucle...

Lo más razonable seria usar otros bucles y condiciones para que se comporte como tal,sin embargo por mas que he intentado no me ha resultado!!!

Aqui va un ejemplo

Código C++:

int* getRandomString() {
int* vs = new int[SIZE];
 
vs[0] = 0;
vs[1] = 0;
vs[2] = 1;
vs[3] = 1;
vs[4] = 0;
srand((unsigned)time( NULL ) ); 
do {
   for (int i = 0; i < SIZE; i++) {
       vs[i] = rand()%2;
   }
} while(!evalFactibility(vs));
return vs;
}
 

La función evalFactibility(vs), lo que hace es decirnos si el arreglo q le enviamos es factible o no, es decir si nos sirve o no, lo que hize en Python fue lo siguiente:

Código Python:

def getRandomString():
   
    vs=[]*size
 
    vs.insert(0,0)
    vs.insert(1,0)
    vs.insert(2,1)
    vs.insert(3,1)
    vs.insert(4,0)
    from random import randint
 
    while not evalFactibility(vs):
        for i in range(size):
            vs.insert(i,(randint(0,100)%2))
            
    return vs
 

En otra parte del código C++, tb me encuentro con un do-while y al hacerlo con while se me ha echo un loop infinito, se podrá solucionar esto???

[razpeitia]

Código Python:

from random import randint #Esto va afuera de la funcion
 
def getRandomString():
    vs = [0, 0, 1, 1, 0] #[]*size siempre regresara [] asi que no tiene caso
 
    while not evalFactibility(vs): #No se que haga evalFactibility
        vs = [randint(0, 1) for i in xrange(size)]
    return vs
 

evalFactibility debería de regresar True o False (True si es factible, False de lo contrario)

[razpeitia]

Código Python:

from random import randint
 
def getRandomString(size):
    #Regresa una lista de tamanio size con 0's y 1's
    return [randint(0, 1) for i in xrange(size)]
 
def evalCoeffs(coeffs, randlist):
    #Asumo que randlist y coeffs tienen el mismo tamanio
    size = len(randlist)
    #Si no llegan a tener el mismo tamanio lanzara una excepcion
    aux = [coeffs[i] * randlist[i] for i in xrange(size)]
    #Regreso la suma de multiplicar los items de coeffs y randlist
    #Y ademas regreso aux, que es multiplicacion de las listas
    return sum(aux), aux
 
def evalFactibility(coeffs, randlist):
    #No tengo idea de que haga evalFactibility
    #Se quede regresar True si cumple con algo
    #Y false si no cumple ese algo
    suma, rlist = evalCoeffs(coeffs, randlist)
    #Supuse que si la suma es mayor o igual a 0 entonces es factible
    #Corrigeme si estoy mal por que no se que es lo hace esta funcion
    if suma >= 0: 
        return True
    return False
    
    
def foundInitialSolutions(lcoeffs):
    initialSolutions = []
    for coeffs in lcoeffs:
        size = len(coeffs)
        vs = getRandomString(size)
        while not evalFactibility(coeffs, vs):
            vs = getRandomString(size)
        initialSolutions.append(vs)
    return initialSolutions
 
list_of_coeffs = [
                  [1,   1,  1,  2,  1],
                  [7,   0,  3, -4,  3],
                  [11, -6,  0,  3, -3]
                 ]
inits = foundInitialSolutions(list_of_coeffs)
print list_of_coeffs
print inits
 

Sigo sin saber BIEN que es lo que hace evalFactibility.

[Ania_]

Si, evalFactibility() devuelve True si es verdadero y False si es falso

Esta es la funcion

Código Python:

csize=3
size=5
ops=[1,1,2]
rhs=[4,8,3]
 
def evalFactibility(vs):
    val=[[0]*size for i in range(csize)]
    for i in range(csize):
        aux=[]
        for j in range(size):
            val[i][j]=coeffs[i][j]*vs[j]
            aux.append(val[i][j])
        aux2=sum(aux)
        if ops[i]==1:
            if not(aux2 <= rhs[i]):                
                return 0 #false
            elif ops[i]==2:
                if not(aux2 >= rhs[i]):
                    return 0 #false
      return 1 #true
 

[razpeitia]

Código Python:

from random import randint
 
def getRandomString(size):
    #Regresa una lista de tamanio size con 0's y 1's
    return [randint(0, 1) for i in xrange(size)]
 
def evalCoeffs(coeffs, randlist):
    #Asumo que randlist y coeffs tienen el mismo tamanio
    size = len(randlist)
    #Si no llegan a tener el mismo tamanio lanzara una excepcion
    aux = [coeffs[i] * randlist[i] for i in xrange(size)]
    #Regreso la suma de multiplicar los items de coeffs y randlist
    #Y ademas regreso aux, que es multiplicacion de las listas
    return sum(aux), aux
 
def evalFactibility(coeffs, randlist, ops, rhs):
    #No tengo idea de que haga evalFactibility
    #Se quede regresar True si cumple con algo
    #Y false si no cumple ese algo
    suma, rlist = evalCoeffs(coeffs, randlist)
    #Supuse que si la suma es mayor o igual a 0 entonces es factible
    #Corrigeme si estoy mal por que no se que es lo hace esta funcion
    if ops == 1:
        if suma > rhs:
            return False
    elif ops == 2:
        if suma < rhs:
            return False
    return True
    
    
def foundInitialSolutions(lcoeffs, ops, rhs):
    initialSolutions = []
    for coeffs, op, rh in zip(lcoeffs, ops, rhs):
        size = len(coeffs)
        vs = getRandomString(size)
        while not evalFactibility(coeffs, vs, op, rh):
            vs = getRandomString(size)
        initialSolutions.append(vs)
    return initialSolutions
 
list_of_coeffs = [
                  [1,   1,  1,  2,  1],
                  [7,   0,  3, -4,  3],
                  [11, -6,  0,  3, -3]
                 ]
ops = [1, 1, 2]
rhs = [4, 8, 3]
inits = foundInitialSolutions(list_of_coeffs, ops, rhs)
print list_of_coeffs
print inits
 

Te recomiendo que leas python para todos te ayudara a entender muchas cosas.

[Ania_]

Justamente es el que estoy usando para aprender Python, lo que sí no he podido adentrar mucho, porque esta tarea se trata de pasar un codigo en C++ a Python, por lo que he tenido que buscar cosas puntuales.

De todas maneras, si me puedes recomendar otros textos, una vez que avanze un poco más te estaria agradecida...

Gracias por la ayuda

[razpeitia]

Claro que si documentación, turoriales y libros de python nunca faltan.

Te recomiendo que termines python para todos antes de empezar dive into python. Si puedes leerlo en ingles mejor por que la versión en español esta muy recordaba. Y sobre todo practica! sin practica por mas que leas no sabrás como implementar esto o aquello.