mejorar mi codigo

hola, !

... tengo la siguente funcion que utilizo para actualizar cantidades a disttintos tipos de interes de forma acumulada.
Las cantidades son datos que tengo e una hoja de calculo y se las paso a la funcion.
Me gustaria saber como poder hacer esta funcion utilizando arrays, es decir, un aray para los importes y otro para los porcentajes...

para entender el funcionamiento de la funcion, seria conveniente que aportes algunos detalles complementarios (p.e.)

1) cual de los importes es el mas antiguo o el mas reciente (el imp1 o el imp8) ???
2) por que la funcion solicita los importes en orden ascendente y en el algoritmo los trabajas en descendente ???
3) por que no se acumulan (intereses ?) a los imp1 e imp2 ???
4) cual es el objetivo final de esta funcion ???
5) siempre se opera con 8 argumentos (importes y tasas) ???
6) cualquier detalle acerca del funcionamiento y objetivos que no paso en tu consulta ?

saludos,
hector.

__ el codigo expuesto __

Function ActualizaImp (imp1, imp2, imp3, imp4, imp5, imp6, imp7, imp8 As Double) As Double
Dim A As Double, B As Double, C As Double, D As Double, E As Double, F As Double, G As Double
Dim H As Double
PORC1 = 0.016
PORC2 = 0.027
PORC3 = 0.022
PORC4 = 0.017
PORC5 = 0.012
PORC6 = 0.012
PORC7 = 0.014
PORC8 = 0.021
A = ((((((((imp8 * (1 + PORC8)) * (1 + PORC7)) * (1 + PORC6)) * (1 + PORC5)) * (1 + PORC4)) * (1 + PORC3)) * (1 + PORC2)) * (1 + PORC1))
B = (((((((imp7 * (1 + PORC7)) * (1 + PORC6)) * (1 + PORC5)) * (1 + PORC4)) * (1 + PORC3)) * (1 + PORC2)) * (1 + PORC1))
C = ((((((imp6 * (1 + PORC6)) * (1 + PORC5)) * (1 + PORC4)) * (1 + PORC3)) * (1 + PORC2)) * (1 + PORC1))
D = (((((imp5 * (1 + PORC5)) * (1 + PORC4)) * (1 + PORC3)) * (1 + PORC2)) * (1 + PORC1))
E = ((((imp4 * (1 + PORC4)) * (1 + PORC3)) * (1 + PORC2)) * (1 + PORC1))
F = (((imp3 * (1 + PORC3)) * (1 + PORC2)) * (1 + PORC1))
G = (imp2) * 1
H = (imp1) * 1
ActualizaImp = A + B + C + D + E + F + G + H
End Function

Creo que una manera pudiera ser esta

Public Function ActualizaImp2(Cantidades As Variant, Optional Porcentajes As
Variant) As Double

Dim Cant() As Double
Dim Porc() As Double
Dim Factores() As Double
Dim I As Integer
Dim J As Integer
Dim Numero As Integer
Dim Valor As Variant
Dim Temp As Double
Dim Suma As Double

Numero = Cantidades.Count - 1

I = 0
For Each Valor In Cantidades

ReDim Preserve Cant(I)
Cant(I) = CDbl(Valor)
I = I + 1
Next Valor

If Not IsMissing(Porcentajes) Then
I = 0
For Each Valor In Porcentajes
ReDim Preserve Porc(I)
Porc(I) = CDbl(Valor)
I = I + 1
Next Valor

Else
ReDim Porc(I - 1)

If Numero <> 7 Then Suma = 1 / 0

Porc(0) = 0.016
Porc(1) = 0.027
Porc(2) = 0.022
Porc(3) = 0.017
Porc(4) = 0.012
Porc(5) = 0.012
Porc(6) = 0.014
Porc(7) = 0.021

End If
ReDim Factores(2 To Numero)

Temp = 0
Suma = 0
For I = 2 To Numero
Temp = Cant(I)
For J = 0 To I

Temp = Temp * (1 + Porc(J))

Next J
Suma = Suma + Temp
Next I

ActualizaImp2 = Suma + Cant(1) + Cant(0)

End Function


Esta forma te permite manejar cantidades diferentes de ocho, por si lo
necesitas

Si no introduces porcentajes, los valores que indicas son tomados por
defecto

Espero que esto te ayude

Saludos
Alexander Chacin


"j_lete" escribió en el mensaje de
noticias news:

Hola grupo, tengo la siguente funcion que utilizo para actualizar
cantidades
a disttintos tipos de interes de forma acumulada.
Las cantidades son datos que tengo e una hoja de calculo y se las paso a
la
funcion.
Me gustaria saber como poder hacer esta funcion utilizando arrays, es
decir,
un aray para los importes y otro para los porcentajes.

Gracias anticipadas por la ayuda que me puedan prestar.

Function ActualizaImp (imp1, imp2, imp3, imp4, imp5, imp6, imp7, imp8 As
Double) As Double

Dim A As Double, B As Double, C As Double, D As Double, E As Double, F As
Double, G As Double
Dim H As Double

PORC1 = 0.016
PORC2 = 0.027
PORC3 = 0.022
PORC4 = 0.017
PORC5 = 0.012
PORC6 = 0.012
PORC7 = 0.014
PORC8 = 0.021

A = ((((((((imp8 * (1 + PORC8)) * (1 + PORC7)) * (1 + PORC6)) * (1 +
PORC5))
* (1 + PORC4)) * (1 + PORC3)) * (1 + PORC2)) * (1 + PORC1))
B = (((((((imp7 * (1 + PORC7)) * (1 + PORC6)) * (1 + PORC5)) * (1 +
PORC4))
* (1 + PORC3)) * (1 + PORC2)) * (1 + PORC1))
C = ((((((imp6 * (1 + PORC6)) * (1 + PORC5)) * (1 + PORC4)) * (1 + PORC3))
*
(1 + PORC2)) * (1 + PORC1))
D = (((((imp5 * (1 + PORC5)) * (1 + PORC4)) * (1 + PORC3)) * (1 + PORC2))
*
(1 + PORC1))
E = ((((imp4 * (1 + PORC4)) * (1 + PORC3)) * (1 + PORC2)) * (1 + PORC1))
F = (((imp3 * (1 + PORC3)) * (1 + PORC2)) * (1 + PORC1))
G = (imp2) * 1
H = (imp1) * 1

ActualizaImp = A + B + C + D + E + F + G + H
End Function

hola, chicos ! (solo por no "dejarlo en el tintero")...

las (re)preguntas que hago a OP no son "solo por molestar" y se basan en lo siguiente:

- la forma de interes compuesto que hace a cada "imp" (imp1...imp8) es lo que hace la funcion VF.PLAN (FvSchedule en ingles)

- podria salir mas barato usar celdas auxiliares (con esta funcion) y en lugar de una funcion personalizada (simplemente) SUMAR

- la omision que hace para acumular intereses a los argumentos "imp1" e "imp2" podria ser relevante (?)

- tambien "el orden" diferente en que la funcion "toma" los argumentos (en ascendente) y los procesa (en descendente)
esto podria alterar la forma en que la funcion propuesta por Alexander va rellenando las matrices (For...Next)

- tambien tendria "su impacto" si en la realidad OP necesita MAS de 8 argumentos (???)

- (aparentemente) la propuesta de Alexander "intenta" producir/devolver/... el valor de error div/0! (aunque no hay divisiones ???)

- si este punto es acertado (?) probablemente convendria modificar esta linea de la funcion...
If Numero <> 7 Then Suma = 1 / 0
por este otro metodo...
If Numero <> 7 Then ActualizaImp2 = CVErr(xlErrDiv0): Exit Function

- pero quizas seria mas apropiado devolver otro tipo de error (indicar que algun elemento NO esta disponible entre las matrices)...
If Numero <> 7 Then ActualizaImp2 = CVErr(xlErrNA): Exit Function

- aunque NO se podrian devolver "tipos de error" a menos que la funcion se declare como Variant (o sin tipo "por omision")

en fin... en este tipo de consultas siempre resulta conveniente recibir algun "feed-back" por parte del OP (?)

saludos,
hector.

Buenos días

Héctor, a mi también me pareció que faltaba información, pero como la
pregunta hace énfasis en la toma de datos desde un rango de celdas, comencé
esa parte. Luego traté de darle la funcionalidad de tomar más o menos de 8
argumentos

No entiendo tu comentario acerca del "orden", como tu lo llamas, para
procesar los datos, la función original genera un valor de salida, no una
matriz, El orden de las multiplicaciones no altera el producto. Como se
pregunta la mejor manera de codificar y no se dan mayores
restricciones uso la alternativa más sencilla.

Tampoco entiendo que impacto tendria si se necesitan más de 8 argumentos, si
miras bien el código, está considerado, de cualquier manera si encuentras
algo que no funcione, solo tienes que mecionarlo y lo corrijo, pero
mencionar dudas que no se concretan en nada, no me parece apropiado

En lo que respecta al error creado "a mano", lo hice por facilidad, estoy un
poco escaso de tiempo para hacer una rutina de simulación de errores formal

Para finalizar escribí para hacer un aporte, no tengo la costumbre de
corregir los aportes de otros integrantes del grupo, creo que si alguien se
tomó la molestia de responder, de entregar parte de su tiempo para ayudar a
otra persona, merece toda mi atención y aunque no me diga nada nuevo igual
lo leo. Si tu consideraste que debias preguntar para resolver tus dudas, me
parece muy bien, yo estaba preparando mi respuesta y por falta de tiempo no
pude enviarla antes de tu aporte, tomé algunas consideraciones y asumí
algunas premisas a causa de la poca información y de que tus dudas no fueron
respondidas

Lo que si es importante es que la persona que hizo la consulta, leerá las
respuestas y seguramente dará la información adicional que solicitas o dirá
que debe ser modificado en mi propuesta. Si no es así espero que mi aporte
pueda ayuda a alguien

Saludos
Alexander Chacin

"Héctor Miguel" escribió en el mensaje de
noticias news:e4TMCFH$

hola, chicos ! (solo por no "dejarlo en el tintero")...

las (re)preguntas que hago a OP no son "solo por molestar" y se basan en
lo siguiente:

- la forma de interes compuesto que hace a cada "imp" (imp1...imp8) es lo
que hace la funcion VF.PLAN (FvSchedule en ingles)

- podria salir mas barato usar celdas auxiliares (con esta funcion) y en
lugar de una funcion personalizada (simplemente) SUMAR

- la omision que hace para acumular intereses a los argumentos "imp1" e
"imp2" podria ser relevante (?)

- tambien "el orden" diferente en que la funcion "toma" los argumentos (en
ascendente) y los procesa (en descendente)
esto podria alterar la forma en que la funcion propuesta por Alexander va
rellenando las matrices (For...Next)

- tambien tendria "su impacto" si en la realidad OP necesita MAS de 8
argumentos (???)

- (aparentemente) la propuesta de Alexander "intenta"
producir/devolver/... el valor de error div/0! (aunque no hay divisiones
???)

- si este punto es acertado (?) probablemente convendria modificar esta
linea de la funcion...
If Numero <> 7 Then Suma = 1 / 0
por este otro metodo...
If Numero <> 7 Then ActualizaImp2 = CVErr(xlErrDiv0): Exit Function

- pero quizas seria mas apropiado devolver otro tipo de error (indicar que
algun elemento NO esta disponible entre las matrices)...
If Numero <> 7 Then ActualizaImp2 = CVErr(xlErrNA): Exit Function

- aunque NO se podrian devolver "tipos de error" a menos que la funcion se
declare como Variant (o sin tipo "por omision")

en fin... en este tipo de consultas siempre resulta conveniente recibir
algun "feed-back" por parte del OP (?)

saludos,
hector.

Hola Hector:
Ya he leido tu siguiente post y está claro que no lo haces por "molestar".
Cuando alguien (yo) expongo un problema, se da por sentado que todo el mundo
sabe lo que hago o pretendo hacer, por lo que se puede obviar información.
DIcho esto, contesto tus cuestiones

1) el importe mas actual es el 1 y el mas antiguo el 8.
2) los datos estan en una hoja (rango b7:b15 para el primer registro, siendo
b7 el mas actual y b15 el mas antiguo. El siguinte registro los valores son
c7:c15 y así sucesivamente). Respecto al orden del algoritmo, lo hice así del
mas complicado al mas sencillo. De todas formas al final sumo los valores que
son los que aparecen en la celda resultado b16 para el 1 registro c16 segundo
y así...
3)los dos valores iniciales no se actualizan, pero su valor si se suma al
total.
4)conocer cual sería el importe actualizado al un % actualizado de precios
de productos de los últimos 8 año, dejando sin actualizar los 2 primeros.
5) entre 8 y 16, pero en principio 8
La 6) no la entiendo muy bien.

Gracias por tu ayuda.
Saludos

"Héctor Miguel" escribió:

hola, !

> ... tengo la siguente funcion que utilizo para actualizar cantidades a disttintos tipos de interes de forma acumulada.

> Las cantidades son datos que tengo e una hoja de calculo y se las paso a la funcion.
> Me gustaria saber como poder hacer esta funcion utilizando arrays, es decir, un aray para los importes y otro para los porcentajes...

para entender el funcionamiento de la funcion, seria conveniente que aportes algunos detalles complementarios (p.e.)

1) cual de los importes es el mas antiguo o el mas reciente (el imp1 o el imp8) ???
2) por que la funcion solicita los importes en orden ascendente y en el algoritmo los trabajas en descendente ???
3) por que no se acumulan (intereses ?) a los imp1 e imp2 ???
4) cual es el objetivo final de esta funcion ???
5) siempre se opera con 8 argumentos (importes y tasas) ???
6) cualquier detalle acerca del funcionamiento y objetivos que no paso en tu consulta ?

saludos,
hector.

__ el codigo expuesto __
> Function ActualizaImp (imp1, imp2, imp3, imp4, imp5, imp6, imp7, imp8 As Double) As Double
> Dim A As Double, B As Double, C As Double, D As Double, E As Double, F As Double, G As Double
> Dim H As Double
> PORC1 = 0.016
> PORC2 = 0.027
> PORC3 = 0.022
> PORC4 = 0.017
> PORC5 = 0.012
> PORC6 = 0.012
> PORC7 = 0.014
> PORC8 = 0.021
> A = ((((((((imp8 * (1 + PORC8)) * (1 + PORC7)) * (1 + PORC6)) * (1 + PORC5)) * (1 + PORC4)) * (1 + PORC3)) * (1 + PORC2)) * (1 + PORC1))
> B = (((((((imp7 * (1 + PORC7)) * (1 + PORC6)) * (1 + PORC5)) * (1 + PORC4)) * (1 + PORC3)) * (1 + PORC2)) * (1 + PORC1))
> C = ((((((imp6 * (1 + PORC6)) * (1 + PORC5)) * (1 + PORC4)) * (1 + PORC3)) * (1 + PORC2)) * (1 + PORC1))
> D = (((((imp5 * (1 + PORC5)) * (1 + PORC4)) * (1 + PORC3)) * (1 + PORC2)) * (1 + PORC1))
> E = ((((imp4 * (1 + PORC4)) * (1 + PORC3)) * (1 + PORC2)) * (1 + PORC1))
> F = (((imp3 * (1 + PORC3)) * (1 + PORC2)) * (1 + PORC1))
> G = (imp2) * 1
> H = (imp1) * 1
> ActualizaImp = A + B + C + D + E + F + G + H
> End Function