lunes, 8 de abril de 2013


"Manual de Comunicación Política y Estrategias de Campaña" ÍNDICE TEMÁTICO

Publicado el junio 8, 2011

Por marioriorda

En http://marioriorda.com/


"Manual de Comunicación Política y Estrategias de Campaña: candidatos, medios y electores en una nueva era"Ismael Crespo-Mario Riorda-Ileana Carletta-Antonio Garrido


　

Indice temático:PRIMERA PARTE.

ESTRATEGIAS DE CAMPAÑA

Capítulo 1. ¿HAY UNA ESTRATEGIA DE CAMPAÑA ELECTORAL QUE SEA MÁS EFECTIVA?
Funciones electorales: información, movilización y persuasión
Proporcionar información
Movilizar al electorado
Persuadir al electorado Las diferentes estrategias de las campañasy sus condicionantes
¿Cómo planificar los tiempos de las campañas?
La planificación y la relación con algunos medios.
　
Capítulo 2. CONTEXTOS ELECTORALES Y TENDENCIAS DE VOTO
Las reglas del juego
Contextos y entrada de candidatos en la campaña
Tendencia al bipartidismo en contextos de mayoría relativa
La dispersión de candidatos en contextos de doble vuelta
Otros factores que influyen en la entrada de candidatos
Análisis de escenarios y tendencias de voto
El escenario del "ganador anticipado"
El escenario de la reelección
El escenario del "voto negativo"
El escenario del "centro dividido": La eliminación de los moderados y la polarización
El escenario del "multipartidismo bipolar desequilibrado"
El escenario del "outsider"
Excurso: Análisis de microtendencias.

　

Capítulo 3. ESTRATEGIAS DE LANZAMIENTO Y ELECCIONES PRIMARIASCandidatos
Candidatos potenciales
Outsiders
El anuncio de la candidatura
Estrategia de primarias
Candidatos ideologizados y extremos
Primarias en alianzas o coaliciones electorales presidenciales
Primarias extendidas
Primarias simultáneas a la elección presidencial
La composición de la fórmula presidencial: la selección de los vicepresidentes.
　
Capítulo 4. LIDERAZGOS QUE TRIUNFAN
Ser o no ser: ¿ésa es la cuestión?
Atributos del liderazgo
¿Por qué alguien es líder?
Liderazgo: un modelo para armar
Liderazgo político y comunicación
La comunicación en la construcción del liderazgo
Liderazgo político y comunicación
El político como líder: soft power, hard power y smart power.
　
SEGUNDA PARTE.

COMUNICACIÓN POLÍTICA

Capítulo 5. DECIR MUCHO DICIENDO POCO: LA RED DE TEMAS Y MENSAJES EN CAMPAÑAUn espacio de intercambio
La agenda política
El construccionismo como regla para los mensajes efectivos
Argumentos y eslóganes.
　
Capítulo 6. ¿GENERAR ESPERANZA O INOCULAR VENENO?: COMUNICACIÓN POSITIVA Y NEGATIVAStorytelling, framing, flaming
¿Por qué se debe utilizar comunicación positiva?
Pensando en las categorías de la comunicación positiva
Ayudando a la persuasión
Comunicaciones negativas
Las campañas negativas
Recomendaciones sintéticas
Tipos de campañas negativas
La comunicación negativa y la participación democrática.
　
Capítulo 7. DISCURSOS Y ORATORIA DE CAMPAÑALa estructura de los discursos electorales
El arranque o apertura
El desarrollo o cuerpo de los discursos de campaña
El cierre o conclusión
Transiciones
Elementos retóricos y técnicas de los discursos de campaña electoral
Técnicas retóricas de repetición
Técnicas retóricas de elocuencia poética
Técnicas de polemología retórica
Referencias alusivas y uso de citas
Otros elementos retóricos.
　
Capítulo 8. ¿QUÉ HAY DETRÁS DE LOS DEBATES ELECTORALES?
El enfoque democrático de los debates
El enfoque mediático-tecnológico de los debates
El enfoque del marketing político de los debates
Reflexionando a modo de síntesis.

　

Capítulo 9. LA CAMPAÑA DIGITALWeb 2.0
Los pilares de una campaña presidencial digital
Portales de campaña
Websites de los candidatos
Micro-sitios de campaña
Marketing vía e-mail
Vídeos de la campaña: El fenómeno You Tube
Blogs y nano-blogs: Blogger, WordPress, Twitter
Redes sociales o comunidades virtuales: Las campañas electorales en la era de Facebook- My Space- Facebook - Second Life y LinkedIn. Redes de comunidades minoritarias Aplicaciones para teléfonos móviles y envíos masivos de mensajes vía sms.
　

Tomado de:
http://marioriorda.com/blog/?p=256http://marioriorda.com/blog/?p=256
　
Para Publicar y recomendar este libro se debe tomar en cuenta las Normas de uso del Blog del Doctor Mario Riorda:
http://marioriorda.com/blog/?page

http://marioriorda.com/blog
Publicado por en No hay comentarios:

sábado, 6 de abril de 2013

Retirement : simulating wealth with random returns, inflation and withdrawals – Shiny web application

April 6, 2013
By systematicinvestor
http://www.r-bloggers.com

Today, I want to share the Retirement : simulating wealth with random returns, inflation and withdrawals – Shiny web application (code at GitHub).

This application was developed and contributed by Pierre Chretien, I only made minor updates. This is application is a great example of how easy it is to convert your R script into interactive Shiny web application.

Please see below the sample script to simulate wealth random returns, inflation and withdrawals:


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
#-------------------------------------
# Inputs
#-------------------------------------

# Initial capital
start.capital = 2000000

# Investment
annual.mean.return = 5 / 100
annual.ret.std.dev = 7 / 100

# Inflation
annual.inflation = 2.5 / 100
annual.inf.std.dev = 1.5 / 100

# Withdrawals
monthly.withdrawals = 10000

# Number of observations (in Years)
n.obs = 20

# Number of simulations
n.sim = 200

#-------------------------------------
# Simulation
#-------------------------------------

# number of months to simulate
n.obs = 12 * n.obs


# monthly Investment and Inflation assumptions
monthly.mean.return = annual.mean.return / 12
monthly.ret.std.dev = annual.ret.std.dev / sqrt(12)

monthly.inflation = annual.inflation / 12
monthly.inf.std.dev = annual.inf.std.dev / sqrt(12)


# simulate Returns
monthly.invest.returns = matrix(0, n.obs, n.sim)
monthly.inflation.returns = matrix(0, n.obs, n.sim)
   
monthly.invest.returns[] = rnorm(n.obs * n.sim, mean = monthly.mean.return, sd = monthly.ret.std.dev)
monthly.inflation.returns[] = rnorm(n.obs * n.sim, mean = monthly.inflation, sd = monthly.inf.std.dev)

# simulate Withdrawals
nav = matrix(start.capital, n.obs + 1, n.sim)
for (j in 1:n.obs) {
    nav[j + 1, ] = nav[j, ] * (1 + monthly.invest.returns[j, ] - monthly.inflation.returns[j, ]) - monthly.withdrawals
}

# once nav is below 0 => run out of money
nav[ nav < 0 ] = NA

# convert to millions
nav = nav / 1000000

#-------------------------------------
# Plots
#-------------------------------------
layout(matrix(c(1,2,1,3),2,2))

# plot all scenarios   
matplot(nav, type = 'l', las = 1, xlab = 'Months', ylab = 'Millions',
    main = 'Projected Value of initial capital')

# plot % of scenarios that are still paying
p.alive = 1 - rowSums(is.na(nav)) / n.sim

plot(100 * p.alive, las = 1, xlab = 'Months', ylab = 'Percentage Paying',
    main = 'Percentage of Paying Scenarios', ylim=c(0,100))
grid() 

# plot distribution of final wealth
final.nav = nav[n.obs + 1, ]
    final.nav = final.nav[!is.na(final.nav)]

plot(density(final.nav, from=0, to=max(final.nav)), las = 1, xlab = 'Final Capital',
    main = paste('Distribution of Final Capital,', 100 * p.alive[n.obs + 1], '% are still paying'))
grid() 




The corresponding Shiny web application consists of two files:
  • ui.r – User Interface
  • server.r – R simulations and calculations
Following is the user interface (ui.r) that maps and describes required inputs for the retirement simulation:




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
# Define UI for application that plots random distributions
shinyUI(pageWithSidebar(

  # Application title
  headerPanel("Retirement : simulating wealth with random returns, inflation and withdrawals"),

  # Sidebar with a slider input for number of observations
  sidebarPanel(
    sliderInput("n.obs",
                "Number of observations (in Years):",
                min = 0,
                max = 40,
                value = 20),

    sliderInput("start.capital",
                "Initial capital invested :",
                min = 100000,
                max = 10000000,
                value = 2000000,
                step = 100000,
                format="$#,##0",
                locale="us"),

    sliderInput("annual.mean.return",
                "Annual return from investments (in %):",
                min = 0.0,
                max = 30.0,
                value = 5.0,
                step = 0.5),

    sliderInput("annual.ret.std.dev",
                "Annual volatility from investments (in %):",
                min = 0.0,
                max = 25.0,
                value = 7.0,
                step = 0.1),

    sliderInput("annual.inflation",
                "Annual inflation (in %):",
                min = 0,
                max = 20,
                value = 2.5,
                step = 0.1),

    sliderInput("annual.inf.std.dev",
                "Annual inflation volatility. (in %):",
                min = 0.0,
                max = 5.0,
                value = 1.5,
                step = 0.05),

    sliderInput("monthly.withdrawals",
                "Monthly capital withdrawals:",
                min = 1000,
                max = 100000,
                value = 10000,
                step = 1000,
                format="$#,##0",
                locale="us",),
                 
    sliderInput("n.sim",
                "Number of simulations:",
                min = 0,
                max = 2000,
                value = 200)
                 
  ),

  # Show a plot of the generated distribution
  mainPanel(
    plotOutput("distPlot", height = "600px")
  )
))



The last step is modify the retirement simulation logic to use user inputs:



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
library(shiny)

# Define server logic required to generate and plot a random distribution
#
# Idea and original code by Pierre Chretien
# Small updates by Michael Kapler
#
shinyServer(function(input, output) {

  # Function that generates scenarios and computes NAV.
  getNav <- reactive="" span="">
    #-------------------------------------
    # Inputs
    #-------------------------------------
     
    # Initial capital
    start.capital = input$start.capital
     
    # Investment
    annual.mean.return = input$annual.mean.return / 100
    annual.ret.std.dev = input$annual.ret.std.dev / 100
     
    # Inflation
    annual.inflation = input$annual.inflation / 100
    annual.inf.std.dev = input$annual.inf.std.dev / 100
     
    # Withdrawals
    monthly.withdrawals = input$monthly.withdrawals
     
    # Number of observations (in Years)
    n.obs = input$n.obs
     
    # Number of simulations
    n.sim = input$n.sim
     
    #-------------------------------------
    # Simulation
    #-------------------------------------
     
    # number of months to simulate
    n.obs = 12 * n.obs
     
     
    # monthly Investment and Inflation assumptions
    monthly.mean.return = annual.mean.return / 12
    monthly.ret.std.dev = annual.ret.std.dev / sqrt(12)
     
    monthly.inflation = annual.inflation / 12
    monthly.inf.std.dev = annual.inf.std.dev / sqrt(12)
     
     
    # simulate Returns
    monthly.invest.returns = matrix(0, n.obs, n.sim)
    monthly.inflation.returns = matrix(0, n.obs, n.sim)
       
    monthly.invest.returns[] = rnorm(n.obs * n.sim, mean = monthly.mean.return, sd = monthly.ret.std.dev)
    monthly.inflation.returns[] = rnorm(n.obs * n.sim, mean = monthly.inflation, sd = monthly.inf.std.dev)
     
    # simulate Withdrawals
    nav = matrix(start.capital, n.obs + 1, n.sim)
    for (j in 1:n.obs) {
        nav[j + 1, ] = nav[j, ] * (1 + monthly.invest.returns[j, ] - monthly.inflation.returns[j, ]) - monthly.withdrawals
    }  
     
    # once nav is below 0 => run out of money
    nav[ nav < 0 ] = NA
     
    # convert to millions
    nav = nav / 1000000
     
    return(nav) 
  })
   
  # Expression that plot NAV paths.
  output$distPlot <- renderplot="" span="">
    nav = getNav()

    layout(matrix(c(1,2,1,3),2,2))
     
    # plot all scenarios   
    matplot(nav, type = 'l', las = 1, xlab = 'Months', ylab = 'Millions',
        main = 'Projected Value of initial capital')

         
    # plot % of scenarios that are still paying
    p.alive = 1 - rowSums(is.na(nav)) / ncol(nav)
     
    plot(100 * p.alive, las = 1, xlab = 'Months', ylab = 'Percentage Paying',
        main = 'Percentage of Paying Scenarios', ylim=c(0,100))
    grid() 

         
    last.period = nrow(nav)
     
    # plot distribution of final wealth
    final.nav = nav[last.period, ]
        final.nav = final.nav[!is.na(final.nav)]
     
    if(length(final.nav) ==  0) return()       
     
    plot(density(final.nav, from=0, to=max(final.nav)), las = 1, xlab = 'Final Capital',
        main = paste('Distribution of Final Capital,', 100 * p.alive[last.period], '% are still paying'))
    grid() 
  })
         
})



We all done now!!! Shiny is amazing in the way it allows you to convert your script into interactive web application with just two simple steps.
Please play around with the Retirement : simulating wealth with random returns, inflation and withdrawals – Shiny web application (code at GitHub).
Have a good weekend

Tomado de:

http://www.r-bloggers.com/retirement-simulating-wealth-with-random-returns-inflation-and-withdrawals-shiny-web-application/
Publicado por en No hay comentarios:
Suscribirse a: Entradas (Atom)