R Academy · Aula

Convertendo entre tipos numéricos

Use as.integer(), as.double() e as.numeric() com segurança.

Convertendo entre tipos numéricos é uma aula grátis de R Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de R Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de R Academy inclui 4 aulas no total.

Integer vs Double no R

O R tem dois tipos numéricos: integer (números inteiros, criados com o sufixo L) e double (ponto flutuante, o padrão para literais numéricos). Na maior parte do tempo, o R usa double, mas distingui-los é importante para a segurança de tipos e a eficiência de memória.

x_dbl <- 5        # double by default
x_int <- 5L       # integer (L suffix)

cat('typeof(5):  ', typeof(x_dbl), '
')  # double
cat('typeof(5L): ', typeof(x_int), '
')  # integer
cat('5 == 5L:    ', x_dbl == x_int, '
') # TRUE (values equal)
cat('identical:  ', identical(x_dbl, x_int), '
')  # FALSE (types differ)

as.integer() — Converter para Integer

as.integer(x) converte um valor para integer truncando (não arredondando) a parte decimal. Isso significa que 3.9 se torna 3, não 4. O sufixo L é uma forma simplificada de escrever literais integer.

cat('as.integer(3.7):  ', as.integer(3.7), '
')   # 3 (truncated, not 4)
cat('as.integer(3.2):  ', as.integer(3.2), '
')   # 3
cat('as.integer(-2.9): ', as.integer(-2.9), '
')  # -2 (toward zero)
cat('as.integer(10.9): ', as.integer(10.9), '
')  # 10

# Compare with round
cat('round(3.7):        ', round(3.7), '
')       # 4

as.double() e as.numeric()

as.double(x) e as.numeric(x) são equivalentes: ambas convertem para um valor double (ponto flutuante). Use-as para converter inteiros em doubles quando precisar de precisão fracionária.

count <- 7L  # integer
cat('typeof(count):         ', typeof(count), '
')

dbl_count <- as.double(count)
cat('typeof(as.double(7L)): ', typeof(dbl_count), '
')  # double
cat('Value:                 ', dbl_count, '
')           # 7

# Division automatically promotes to double
cat('7L / 2L:              ', 7L / 2L, '
')            # 3.5 (double)
cat('typeof(7L / 2L):      ', typeof(7L / 2L), '
')    # double

Aritmética com Inteiros

A aritmética com inteiros no R produz inteiros para +, - e *, mas sempre retorna double para /. Isso pode causar surpresa se você esperar que a divisão inteira continue sendo inteira.

a <- 6L
b <- 3L

cat('6L + 3L =', a + b, '| typeof:', typeof(a + b), '
')  # 9 integer
cat('6L - 3L =', a - b, '| typeof:', typeof(a - b), '
')  # 3 integer
cat('6L * 3L =', a * b, '| typeof:', typeof(a * b), '
')  # 18 integer
cat('6L / 3L =', a / b, '| typeof:', typeof(a / b), '
')  # 2 DOUBLE!
cat('6L %/% 3L =', a %/% b, '| typeof:', typeof(a %/% b), '
') # 2 integer

Truncamento vs Arredondamento

Uma distinção importante: as.integer() trunca (remove as casas decimais), enquanto round() arredonda para o número inteiro mais próximo. Seja sempre explícito sobre o comportamento desejado.

values <- c(2.1, 2.5, 2.9, -2.1, -2.5, -2.9)

cat('Original:     ', values, '
')
cat('as.integer():  ', as.integer(values), '
')  # truncate toward 0
cat('round():       ', round(values), '
')       # banker rounding
cat('floor():       ', floor(values), '
')       # round down
cat('ceiling():     ', ceiling(values), '
')     # round up

Risco de Estouro de Inteiro

Os inteiros no R têm 32 bits e podem armazenar valores de até aproximadamente ±2,1 bilhões. Exceder esse intervalo causa um NA com um aviso. Doubles podem armazenar valores muito maiores (até aproximadamente 1,8 × 10^308).

max_int <- .Machine$integer.max
cat('Max integer:', max_int, '
')  # 2147483647

# Overflow produces NA
cat('max_int + 1L:', max_int + 1L, '
')  # NA with warning

# Double handles it fine
cat('as.double(max_int) + 1:', as.double(max_int) + 1, '
')  # 2147483648

O Sufixo L em Vetores

Você pode criar vetores integer usando o sufixo L em cada elemento ou passando uma sequência por as.integer(). O operador de dois-pontos : produz inteiros automaticamente.

# Colon produces integers
seq_int <- 1:5
cat('1:5 typeof:', typeof(seq_int), '
')  # integer

# Explicit integer vector
vec_int <- c(10L, 20L, 30L, 40L)
cat('c(10L,...) typeof:', typeof(vec_int), '
')  # integer

# as.integer on a vector
vec_dbl <- c(1.1, 2.9, 3.5, 4.7)
cat('as.integer(c(1.1,...)):', as.integer(vec_dbl), '
')  # 1 2 3 4

Memória e Desempenho

Integers usam 4 bytes por elemento; doubles usam 8 bytes. Para vetores muito grandes de números inteiros, usar integers pode reduzir pela metade o uso de memória. No entanto, operações aritméticas entre tipos mistos promovem automaticamente o resultado para double.

n <- 1000000L

vec_int <- 1:n          # integer: 4 bytes each
vec_dbl <- as.double(1:n)  # double: 8 bytes each

cat('Integer vector size:', object.size(vec_int), 'bytes
')
cat('Double vector size: ', object.size(vec_dbl), 'bytes
')
cat('Ratio:', as.numeric(object.size(vec_dbl)) / as.numeric(object.size(vec_int)), '
')

Verificando o Armazenamento Integer com is.integer()

Use sempre is.integer() (não is.numeric()) quando precisar verificar especificamente o armazenamento integer. Um número sem o sufixo L é double, mesmo que pareça um número inteiro.

a <- 5    # looks like integer, but it is double
b <- 5L   # true integer

cat('is.integer(5):  ', is.integer(a), '
')   # FALSE!
cat('is.integer(5L): ', is.integer(b), '
')   # TRUE
cat('is.numeric(5):  ', is.numeric(a), '
')   # TRUE
cat('is.numeric(5L): ', is.numeric(b), '
')   # TRUE
cat('class(5):       ', class(a), '
')        # numeric
cat('class(5L):      ', class(b), '
')        # integer

Exemplo de Fluxo de Conversão

Um fluxo de trabalho prático: leia os dados como doubles (o padrão), faça os cálculos e depois converta explicitamente os resultados para integers onde números inteiros forem necessários (por exemplo, contagens, índices e IDs).

# Simulated: reading counts as doubles (common from CSV)
counts_raw <- c(12.0, 8.0, 15.0, 3.0, 22.0)
cat('typeof raw:', typeof(counts_raw), '
')  # double

# Convert to integer for proper storage
counts_int <- as.integer(counts_raw)
cat('typeof converted:', typeof(counts_int), '
')  # integer
cat('Counts:', counts_int, '
')
cat('Total:', sum(counts_int), '
')

Resumo da Conversão Numérica

Principais funções de conversão para tipos numéricos:

as.integer(x) — trunca para integer (remove as casas decimais, em direção a zero)
as.double(x) / as.numeric(x) — converte para double
round(x) — arredonda para o valor mais próximo (use para valores semelhantes a inteiros)
floor(x) / ceiling(x) — arredonda para baixo / para cima
Sintaxe 5L — literal integer (não requer conversão)
1:n — sempre produz integers

x <- 7.8
cat('as.integer(7.8):', as.integer(x), '
')  # 7 (truncate)
cat('round(7.8):     ', round(x), '
')       # 8
cat('floor(7.8):     ', floor(x), '
')       # 7
cat('ceiling(7.8):   ', ceiling(x), '
')     # 8

Verificação Rápida

O que as.integer(3.9) retorna no R?

Recapitulação: Conversão de Tipos Numéricos

Excelente! Principais aprendizados desta lição:

O R tem dois tipos numéricos: integer (sufixo L, 4 bytes) e double (padrão, 8 bytes)
as.integer(x) trunca em direção a zero — não arredonda
as.double() e as.numeric() são idênticas — convertem para double
/ sempre retorna double, mesmo com operandos integer
1:n cria sequências integer; literais numéricos sem L são double
O estouro de integer ocorre em aproximadamente 2,1 bilhões → use double para números inteiros muito grandes

# Demonstrate truncation vs rounding
test_vals <- c(0.1, 0.5, 0.9, 1.5, 2.5, 3.7)
cat('Values:      ', test_vals, '
')
cat('as.integer(): ', as.integer(test_vals), '
')  # truncation
cat('round():      ', round(test_vals), '
')       # nearest (banker)

Perguntas Frequentes

A aula “Convertendo entre tipos numéricos” é grátis?

Sim — o texto completo de “Convertendo entre tipos numéricos” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de R Academy, atualize para CoddyKit PRO. O curso de R Academy inclui 4 aulas no total.

O que vou aprender em “Convertendo entre tipos numéricos”?

Use as.integer(), as.double() e as.numeric() com segurança. Você pratica R Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar R Academy?

Nenhuma experiência prévia é necessária. R Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Convertendo entre tipos numéricos”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de R Academy?

Sim. Cada aula de R Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para R Academy