Bacharel e licenciado em Ciências Biológicas, estou me preparando para o mestrado em Ecologia Vegetal.

Criar uma função que demonstra gráficamente o comportamento de populações (número a ser escolhido pelo usuário) em competição a partir dos parâmetros do modelo de competição de Lotka-Volterra. A função irá perguntar ao usuário todos os valores dos parâmetros. Alternativamente poder-se-ia entrar com uma tabela padronizada com esses parâmetros. A partir do modelo inicial em que a capacidade de suporte de cada população é constante, pode-se implementar capacidade de suporte variável com o tempo. Implementar também efeito de perturbação em um dado tempo.

Muito boa. O R é uma ótima ferramenta para estudar modelos teóricos por simulação. Apenas atenção à distinção entre modelos de crescimento discreto, que vc pode simular com loops, e modelo contínuos como sistemas de equação diferenciais do tipo Lotka-Volterra. Neste segundo caso, o usuário definiria os parâmetros das equações diferenciais, que então devem ser integradas no tempo para vc ter os valores dos tamanhos populacionais. O R tem rotinas para isto. Se vc ir por esta via veja o pacote odesolve, geral, e o pacote simecol, específico para simulações ecológicas. Mas nada contra a solução discreta, apenas colocando os pingos nos i's.

Acabei trabalhando com loops em um modelo de crescimento discreto. Ainda quero implementar vários detalhes, e possívelmente refazer a função com modelo contínuo, como sugerido.

Faltou o plano B.

Como eu já havia começado a função, e sou cabeça dura, me empenhei no plano A. Funcionou, a função roda legal! :D

compet                package:unknown                R Documentation

		Simulação do modelo de competição de Lotka-volterra

Description:

     Uma função totalmente interativa para simular a competição entre populações atráves do modelo de competição de 
	Lotka-Volterra. Gera gráficos do comportamento das populações no tempo, com e sem competição. Todos os pa-
	rametros são determinados pelo usuário.

Usage:

     compet()

Details:

     Os parâmetros definidos pelo usuário são:
	
	-número de populações a simular;
	-tamanho das populações (N);
	-capacidade de suporte das populações (K);
	-taxa de crescimento intrínseca das populações (r);
	-tempo de observação (t);
	-coeficientes de competição entre populações.
	

Warning:

     Não simule muitas populações, pois quanto mais populações, mais parâmetros terá que dar à função.
	Ainda assim, é possível simular quantas populações quiser.

Note:

     A função simula tanto a competição intra como interespecífica.
	
     Além da competição, é possível incluir efeitos da Facilitação. Basta usar coeficientes de competição nega-
	tivos.

     Ainda por implementar:
	
	-possibilidade do usuário entrar com uma tabela com os valores dos parâmetros;
	-entrada dos parâmetros como argumentos da função;
	-capacidade de suporte variável com o tempo;
	-competição intraespecífica para o gráfico sem competição interespecífica;
	-impacto de perturbação em algum tempo;
	-retardos de efeito sobre populações.
	

Author(s):

     Gabriel Ponzoni Frey

References:

     GOTELLI, Nicolas J. Ecologia. Terceira edição. Londrina. Ed. Planta, 2007

compet= function()

{
cat("\n")
cat("\n")
cat("\n")
cat("\n")
cat("\n")
cat("\n")
cat("\n")
cat("\n")
cat("\n")

cat("    BEM VINDO A FUNCAO INTERATIVA DO MODELO DE COMPETICAO DE LOTKA-VOLTERRA   ")
cat("\n")
cat("\n")
cat("\n")
cat("A função vai calcular o comportamento das populacoes discretamente no tempo,")
cat("\n")
cat("e retornara os resultados em forma de graficos sem e com competicao.")
cat("\n")
cat("\n")
cat("Alem da competicao, voce podera ver os efeitos da facilitação no modelo. Basta seguir as instrucoes!")
cat("\n")
cat("\n")
cat("OBS: As formulas foram obtidas no cap. 5 do livro Ecology de Nicolas J. Gotelli.")
cat("\n")
cat("\n")
cat("\n")
cat("\n")
cat("\n")
cat("\n")
cat("\n")
cat("\n")
cat("\n")
cat("\n")
cat("\n")
cat("\n")
cat("\n")
cat("\n")
cat("\n")
cat("\n")
readline("Pressione qualquer tecla para continuar")


#Você tem uma tabela com os dados?
##IMPLEMENTAR##


##############################
#Qual o número de populações?#
##############################
  cat("ATENÇÃO, NÃO simule muitas populações, ou passara muito tempo digitando!!")
  cat("\n")
  pop = readline("    Simular quantas populacoes?  ")
  pop = as.numeric(pop)
  pop  #fazer a checagem....

###################################
#Qual o tamanho de cada populacao?#
###################################

  npop=c(rep(NA,pop))
  npop=matrix(npop,1,pop)
  rownames(npop)="n0"


  for(i in 1:pop) 
 { 
	npop[i]=as.numeric((readline(paste("Numero de individuos da populacao", i, "?  ")	)))
 }   #pergunta o tamanho de cada população

for(i in 1:pop) { colnames(npop)=paste("pop", 1:pop,sep="") } #define os nomes das populações

npop


#################################################
#Qual a capacidade de suporte de cada população?#
#################################################


capacidade=c(rep(NA,pop))
capacidade=matrix(capacidade,1,pop)
rownames(capacidade)="K"

for(i in 1:pop) 
	{ 
	capacidade[i]=as.numeric((readline(paste("Capacidade de suporte da populacao", i, "?  ")	)))
	} # pergunta a capacidade de suporte de cada população


for(i in 1:pop) 
	{ 
	colnames(capacidade)=paste("K", 1:pop,sep="") 
	} #define os nomes das colunas

#capacidade


#####IMPLEMENTAR:  Capacidade de suporte oscila com o tempo?#########


##############################################################
#Qual a taxa de crescimento intrínseca de cada população (r)?#
##############################################################


taxa.crescimento=c(rep(NA,pop))
taxa.crescimento=matrix(taxa.crescimento,1,pop)
rownames(taxa.crescimento)="r"


for(i in 1:pop) 
	{ 
	taxa.crescimento[i]=as.numeric((readline(paste("Taxa de crescimento intrinseca da população", i, "?  ")	)))
	} #define a taxa de crescimento intrínseca de cada população


for(i in 1:pop) 
	{ 
	colnames(taxa.crescimento)=paste("r", 1:pop,sep="") 
	} #define os nomes das colunas

#taxa.crescimento 


#############################
#Quanto tempo de observação?#
#############################


tempo=as.numeric(readline("Quanto tempo de observacao?  "))
#tempo


########################################################################
#Gerando então a matriz de tamanho populacional (sem competição ainda).#
########################################################################


npop.tempo=matrix(npop, nrow=tempo+1, ncol=pop) #cria a matriz de tamanho populacional para t tempos
npop.tempo


for (i in 2:(tempo+1)) 
	{ 
	npop.tempo[i,]=npop.tempo[i-1,]+(npop.tempo[i-1,]*taxa.crescimento*((capacidade-npop.tempo[i-1,])/capacidade))
	}
colnames(npop.tempo)=colnames(npop)
rownames(npop.tempo)=seq(from=0, to=tempo)
	
round(npop.tempo)


##########################################
##Definindo os coeficientes de competição#
##########################################


# 1.Quantos coeficientes há? 
	#R: numero de coeficientes = numero de populacoes*(numero de populacoes -1)
# 2. Construir uma matriz de tamanho pop x pop)


coef.comp=matrix(nrow=pop, ncol=pop)

# 3. Perguntar quais os coeficientes:
cat("\n")
cat("\n")
cat("\n")
cat("Para facilitacao, coloque coeficientes negativos.")
cat("\n")
cat("\n")
cat("\n")
for (i in 1:pop)
{ for (j in 1:pop)
	{ #aqui entra o efeito da competicao intra-especifica
		#if(readline("Há competição intraespecífica (S ou N)")=="N")
		#{
			#{ if(i==j) ###se não houver competição intraespecifica, ligar este if
				#{
				#coef.comp[i,j]= 0 
				#}
			#else
				#{
				if(i==j)
					{
					cat("    Comepeticao INTRAespecífica    ")
					}
				coef.comp[i,j]= as.numeric((readline(paste("Coeficiente de competição entre as populações ", i, "e", j, "?  ")	)))
				#}
			#}
		#}
		
	}
}


coef.comp  ######  FUNCIONAAAAA :D ######

##########################
#Populações em competição#
##########################

competindo=matrix(npop, nrow=tempo+1, ncol=pop) #cria a matriz de tamanho populacional para t tempos
competindo
colnames(competindo)=colnames(npop)
rownames(competindo)=seq(from=0, to=tempo)


#matriz de perdas: calcula quanto cada populacao perde por unidade de tempo
perdas=matrix(npop,ncol=pop, nrow=tempo+1)
perdas


for (g in 1:pop)
	{ for(i in 1:(tempo+1))
		{
		perdas[i,g]=sum(coef.comp[,g]*competindo[i,])
		}
	}
round(perdas)


#incluindo as perdas
	for(i in 2:(tempo+1))
		{ 
			#competindo[i,]=competindo[i-1,]+(competindo[i-1,]*taxa.crescimento*((capacidade-competindo[i-1,])/capacidade)) # formula sem as perdas
			competindo[i,]=competindo[i-1,]+(competindo[i-1,]*taxa.crescimento*((capacidade-competindo[i-1,]-perdas[i-1,])/capacidade))
		}

colnames(competindo)=colnames(npop)
competindo


#npop.tempo



#############################################
#        Perturbação# #IMPLEMENTAR   		#
#Perturbação em que tempo? Qual a magnitude?#
#############################################




#Gráficos estáticos
#Implementar com graficos animados

x11(width=60, height=60) #faz uma janela bem grande para melhor vizualização dos gráficos.
par(mfrow = c(2, 1))
for(g in 1:pop)
	{
		plot(x=as.numeric(rownames(npop.tempo)), y=npop.tempo[,g],type="l", bty="l", xlim=c(0,tempo+1), ylim=c(0,max(npop.tempo+5, competindo+5)), xlab="tempo", ylab="Nº de indivíduos")
		lines(x=as.numeric(rownames(npop.tempo)), y=npop.tempo[,g], col=g)
		title(main="Comportamento sem competição")
		par(new=TRUE)
	}
		par(new=FALSE)
par(xpd=NA) #permite escrever fora das áreas do plot
legend(x=0, y=-max(npop.tempo,competindo)/3, legend=colnames(npop),lty=1,col=1:pop, bty="n", ncol=3) #coloca a legenda entre os dois gráficos

for(g in 1:pop)
	{
		plot(x=as.numeric(rownames(competindo)), y=competindo[,g], type="l", bty="l", xlim=c(0,tempo+1), ylim=c(0,max(npop.tempo+5,competindo+5)), xlab="tempo", ylab="Nº de indivíduos")
		lines(x=as.numeric(rownames(competindo)), y=competindo[,g], col=g)
		title(main="Comportamento com competição")
		par(new=TRUE)
	}
		par(new=FALSE)		
par(mfrow=c(1,1))
}

Competicao