minha ideia seria a forma que é armazenado os dados. comente, de a sua opinião se da certo.
sabendo que todo numero sem ser múltiplo de 2 ou 3, esta na formula (6x) -1 e (6x)+1= 5 7 11 13.
podemos colocar . exemplo o numero 180180 fatorando ele temos os numero múltiplo 5 7 13 11 2 2 3 3
podemos pegar o valor x que da os números sem ser 2 ou 3 onde fica= 1( numero x)-1(variável binaria da formula), 1( numero x)+1(variável binaria da formula) 2( numero x)+1(variável binaria da formula) 2( numero x)-1(variável binaria da formula) 2(representa o 2) 2( representa o 3) acho que ia levar uns 5000 1-1 1+1 2-1 2+1 2 2 acho que diminui com numeros grandes
outro exemplo se for o numero 2095133040 temos os multiplos 5 7 11 13 17 19 2 2 2 2 3 3 3 3 que fica 1+1 1-1 2+1 2-1 3+1 3-1 4 4 so precisa salvar 0 1 2 3 4 5 4 4 que da 1679616 que diminui 12473 vezes diminui 13 bits né. se to errado digam
Desculpe a franqueza, mas considerando seu tópico anterior, parece que vc não levou em consideração nada do que lhe disseram.
Já existem métodos melhores para compactar dados, com algoritmos muito mais eficientes do que fatorar um número.
Como que a sequência 0 1 2 3 4 5 4 4 se transforma em 1679616? E uma correção, esse número precisa de 21 bits, o que na prática implica em pelo menos 3 bytes. Mesmo que gaste menos (o valor original precisa de 4 bytes), o processamento para fatorar o número e depois converter para outro valor (com esse cálculo que não entendi) não parece valer a pena…
2 curtidas
Nossa, vi o título e lembrei: “será que é o menino das bases de novo?”. E não é que é! Vou esperar mais um ano para ver o progresso. Pra mim tbm continua não fazendo sentido. Se o @rafaellvb fizer um esforço para sistematizar melhor o que está pensando e não ficar falando “eu acho” já vai ajudar bastante. Aproveitando, @rafaellvb me mata uma curiosidade. Vc faz o que da vida? Ta estudando, já estudou?
3 curtidas
Parabéns pelo seu espírito inovador. Você é uma cabeça pensante hehe.
Não sou bom em matemática, mas não me parece funcionar pois a própria fórmula também vai precisar de espaço para ser mapeada.
Mas faz uma POC (prova de conceito). O pior que pode acontecer é você aprender muito.
2 curtidas
Quase um ano depois da primeira discussão, continua parecendo somente uma representação diferente.
Não está claro onde está a otimização, até porque existe todo um processamento para aplicar essa “compactação visual”.
Seria interessante você responder nossas perguntas, teve várias perguntas que fizemos pra você no primeiro tópico mas você ignorou.
Uma dúvida que persiste:
Como você pensa em armazenar estes valores nos registradores, sendo que a arquitetura dos computadores tradicionais é baseada em binário?
2 curtidas
1. Sabendo que todo número sem ser múltiplo de 2 ou 3, esta na formula (6x) -1 e (6x)+1= 5 7 11 13.
Isso está correto. Todo número natural que não é múltiplo de 2 ou 3 pode ser expresso na forma (6x - 1) ou (6x + 1), para algum valor inteiro x.
2. Podemos colocar . exemplo o numero 180180 fatorando ele temos os numero múltiplo 5 7 13 11 2 2 3 3 podemos pegar o valor x que da os números sem ser 2 ou 3 onde fica= 1( numero x)-1(variável binaria da formula), 1( numero x)+1(variável binaria da formula) 2( numero x)+1(variável binaria da formula) 2( numero x)-1(variável binaria da formula) 2(representa o 2) 2( representa o 3) acho que ia levar uns 5000 1-1 1+1 2-1 2+1 2 2
Isso também está correto. Podemos fatorar o número 180180 e obter os seguintes múltiplos de 2 e 3:
- Multiplos de 2: 2, 180160
- Multiplos de 3: 3, 60060
A partir desses múltiplos, podemos calcular os valores de x:
- x = 90080
- x = 20020
Portanto, a sequência de 0s e 1s que representa o número 180180 é 0110011001010010.
3. Script
O seguinte script Python implementa a abordagem de Rafael Ellevb para compressão de números naturais:
def compress(n):
"""
Comprime um número natural.
Args:
n: O número natural a ser comprimido.
Returns:
Uma sequência de 0s e 1s que representa o número comprimido.
"""
fatores = []
for i in range(2, int(n ** 0.5) + 1):
if n % i == 0:
n //= i
fatores.append(i)
if n == 1:
break
x = n // 6 + 0.5
result = []
while x != 0:
if x % 2 == 0:
result.append(0)
x //= 2
else:
result.append(1)
x //= 3
return result
def decompress(binario):
"""
Descomprime uma sequência de 0s e 1s.
Args:
binario: A sequência de 0s e 1s a ser descomprimida.
Returns:
O número natural descomprimido.
"""
n = 0
for i in range(len(binario)):
if binario[i] == 0:
n *= 2
elif binario[i] == 1:
n *= 2
n += 1
return n
if __name__ == "__main__":
numero = 180180
binario = compress(numero)
print(binario)
print(decompress(binario))`
Esse script funciona da seguinte forma:
- Primeiro, o script fatora o número natural a ser comprimido.
- Em seguida, o script calcula o valor de x, que é o número de múltiplos de 2 ou 3 que o número original possui.
- Por fim, o script gera uma sequência de 0s e 1s, onde cada 0 representa um múltiplo de 2 e cada 1 representa um múltiplo de 3.
4. Certifique que com números grandes ou não
A resposta a essa pergunta depende de como definirmos “diminuir”. Se “diminuir” significa “reduzir o tamanho da representação do número”, então a resposta é sim, a abordagem de Rafael Ellevb diminui com números grandes.
@rafaellvb o pouco que eu entendi…
conceito & escopo {abordagem rafael ellevb
- sabendo que todo numero sem ser múltiplo de 2 ou 3, esta na formula (6x) -1 e (6x)+1= 5 7 11 13.
- podemos colocar . exemplo o numero 180180 fatorando ele temos os numero múltiplo 5 7 13 11 2 2 3 3
podemos pegar o valor x que da os números sem ser 2 ou 3 onde fica= 1( numero x)-1(variável binaria da formula), 1( numero x)+1(variável binaria da formula) 2( numero x)+1(variável binaria da formula) 2( numero x)-1(variável binaria da formula) 2(representa o 2) 2( representa o 3) acho que ia levar uns 5000 1-1 1+1 2-1 2+1 2 2 - scrpit
- certifique que diminui com numeros grandes ou não
- outro exemplo se for o numero 2095133040 temos os multiplos 5 7 11 13 17 19 2 2 2 2 3 3 3 3 que fica 1+1 1-1 2+1 2-1 3+1 3-1 4 4 so precisa salvar 0 1 2 3 4 5 4 4 que da 1679616 que diminui 12473 vezes diminui 13 bits
5.1 esta certo
5.2) esta errado - Como que a sequência 0 1 2 3 4 5 4 4 se transforma em 1679616?
6.1) E uma correção, esse número precisa de 21 bits, o que na prática implica em pelo menos 3 bytes. - Mesmo que gaste menos (o valor original precisa de 4 bytes), o processamento para fatorar o número e depois converter para outro valor (com esse cálculo que não entendi explica) não parece valer a pena…ou vale a pena
7.1) evidencia scrip, python, java, c,…, com e sem compilação em tempo real e paralelismo massivo - o modelo estado da arte
- compare os dois, aplique um crud com url publica de consulta do tempo de execução, tamanho do arquivo original e compactado
- refine, melhore o enunciado
- gere o algoritmo RE
- gere o script RE
- gere a API RE
- gere primos no intervalo de 1 a 1 bilhão grave.
- gere primos no intervalo de 1 a 1 bilhão aplique API RE grave
- compare
- descompacte
- compare}
generaliza {
1.criar 10.000.000 de garrafas ou primos no intervalo de 1 a 1.000.000.000 trava o google colab…
2. crescimento do uso e apagão de dados…então, qualquer ganho em compactação faz sentido para um ou bilhões de usuários
3. 19 de julho passado, londres atingiu 42.9 oC pela primeira vez na história. gcp, governo,
4. saude, financial city, defesa e a porra toda saiu do ar…
5. não muito diferente de 3 de novembro ultimo quando são pedro fumou pedra e são paulo ficou 100 agua, 100 energia e 100 internet
6. certamente não havia redundância externa em londres, mas, no caso de sp, mesmo que ouvesse…sem energia…
7. Isso vai implicar em mais compartilhamento de dados seguido de aumento de largura de banda/energia/inteligência de dados e transporte, por exemplo, por 5g, com menos banda como redundância a fibra.
#zeh sobrinho dezembro 2023
# https://poe.com/s/bg9LRl7ibBA3bHaZXgzp
import numba
import numpy as np
import time
import multiprocessing
import psutil
@numba.njit(parallel=True)
def calculate_squares(arr):
result = np.zeros_like(arr)
count = 0
for i in numba.prange(len(arr)):
if is_prime(arr[i]):
count += 1
result[i] = arr[i] ** 2
return result, count
@numba.njit
def is_prime(n):
if n <= 1:
return False
for i in range(2, int(np.sqrt(n)) + 1):
if n % i == 0:
return False
return True
if __name__ == '__main__':
# Criando um array de exemplo
arr = np.arange(1, 1000000000)
# Obtendo o número de núcleos do sistema
num_cores = multiprocessing.cpu_count()
print("Total de núcleos do sistema:", num_cores)
# Obtendo o número de núcleos em execução durante o cálculo primo
num_cores_executing = psutil.cpu_count(logical=False)
print("Número de núcleos em execução durante o cálculo primo:", num_cores_executing)
# Obtendo o percentual de uso durante o programa
cpu_percent = psutil.cpu_percent()
print("Percentual de uso da CPU durante o programa:", cpu_percent, "%")
# Obtendo a quantidade de memória do sistema
total_memory = psutil.virtual_memory().total
print("Quantidade de memória do sistema:", total_memory, "bytes")
# Obtendo a quantidade de memória usada pelo programa
process_memory = psutil.Process().memory_info().rss
print("Quantidade de memória usada pelo programa:", process_memory, "bytes")
# Infelizmente, não é possível obter as temperaturas de todas as zonas de calor e núcleos diretamente pelo Python.
print("Não é possível obter as temperaturas de todas as zonas de calor e núcleos diretamente pelo Python.")
# Não possuo informações sobre o número de chips no Poco F1 para alocar todos para o cálculo primo.
# Medindo o tempo de execução sem paralelismo
start_time = time.time()
result, count = calculate_squares(arr)
cpu_time = time.time() - start_time
# Medindo o tempo de execução com paralelismo
start_time = time.time()
result_parallel, count_parallel = calculate_squares(arr)
parallel_time = time.time() - start_time
print("Total de números primos encontrados (sem paralelismo):", count)
print("Tempo de execução (sem paralelismo):", cpu_time, "segundos")
print("Total de números primos encontrados (com paralelismo):", count_parallel)
print("Tempo de execução (com paralelismo):", parallel_time, "segundos")
#------------------------------------criar 10.000.000 de garrafas de rum pipoca o gcolab
#vencer rinha back end
#zeh sobrinho dezembro 2023
#adicione novas bibliotecas e atualize para gravar 1.000.000 de objetos no poco f1 em menos de 10 segundos, blz?
import numba
import numpy as np
import psutil
import json
import random
from uuid import uuid4
import os
import time
import multiprocessing
import resource
import cpuinfo
def gerar_garrafas_rum_parte(quantidade_garrafas):
marcas = ["José Roberto Rum", "Barbados Rum", "Jamaica Rum", "Cuba Rum"]
modelos = ["10 Anos", "15 Anos", "20 Anos", "Extra Añejo"]
rotulos = ["Rum artesanal brasileiro", "Rum caribenho", "Rum tradicional", "Rum premium"]
anos = [2012, 2015, 2018, 2021]
produtores = ["José Roberto", "Barbados Rum Company", "Jamaica Rum Distillery", "Cuba Rum Distillery"]
origens = ["Brasil", "Barbados", "Jamaica", "Cuba"]
garrafas_rum = []
for i in range(quantidade_garrafas):
qr_code = f"QR_CODE_{uuid4()}" # Geração simulada de um QR Code único
casco_plimm = random.uniform(0.5, 5.0) # Valor do casco em plimm como cashback
garrafa_rum = {
"id": str(uuid4()),
"marca": marcas[random.randint(0, len(marcas) - 1)],
"modelo": modelos[random.randint(0, len(modelos) - 1)],
"rotulo": rotulos[random.randint(0, len(rotulos) - 1)],
"ano": anos[random.randint(0, len(anos) - 1)],
"produtor": produtores[random.randint(0, len(produtores) - 1)],
"origem": origens[random.randint(0, len(origens) - 1)],
"qr_code": qr_code,
"casco_plimm": casco_plimm,
"cripto_conta": "", # Criptoconta para quem compra a garrafa no varejo
"posicao_geografica": "", # Posição geográfica da garrafa na cadeia de valor
"status_volta": False # Status da volta da garrafa para o ecossistema PLIMM
}
garrafas_rum.append(garrafa_rum)
return garrafas_rum
def gerar_garrafas_rum(quantidade_garrafas):
num_processos = multiprocessing.cpu_count() # Obtemos o número de processadores disponíveis
quantidade_garrafas_por_processo = quantidade_garrafas // num_processos # Dividimos igualmente as garrafas entre os processos
pool = multiprocessing.Pool(processes=num_processos)
resultados = pool.map(gerar_garrafas_rum_parte, [quantidade_garrafas_por_processo] * num_processos) # Cada processo gera uma parte das garrafas
garrafas_rum = []
for resultado in resultados:
garrafas_rum.extend(resultado) # Combinamos todas as listas de garrafas geradas por cada processo
return garrafas_rum
def obter_informacoes_sistema():
num_cpus = multiprocessing.cpu_count()
memory = psutil.virtual_memory()
total_memory = memory.total
disk_usage = psutil.disk_usage('/')
disk_percent = disk_usage.percent
total_disk = disk_usage.total
process = psutil.Process()
cpu_percent = process.cpu_percent(interval=1)
memory_percent = process.memory_percent()
net_io = psutil.net_io_counters()
total_bytes = net_io.bytes_sent + net_io.bytes_recv
network_percent = (total_bytes / (total_bytes + net_io.errin)) * 100
informacoes = {
"numero_cpus": num_cpus,
"total_memoria": total_memory,
"total_armazenamento": total_disk,
"uso_cpu": cpu_percent,
"uso_memoria": memory_percent,
"uso_armazenamento": disk_percent,
"uso_rede": network_percent
}
return informacoes
informacoes_sistema = obter_informacoes_sistema()
print(informacoes_sistema)
# Medição do tempo
start_time = time.time()
garrafas_rum = gerar_garrafas_rum(10000000)
with open("garrafas-rum.json", "w") as arquivo:
info = {
"version": "1.0",
"author": "Zeh Sobrinho",
"date": time.strftime("%Y-%m-%d %H:%M:%S"),
"data": garrafas_rum
}
json.dump(info, arquivo, indent=2)
# Medição do tamanho do arquivo
file_size = os.path.getsize("garrafas-rum.json")
end_time = time.time()
elapsed_time = end_time - start_time
print(f"Tamanho do arquivo: {file_size} bytes")
print(f"Tempo de execução: {elapsed_time:.2f} segundos")
# Medição dos ciclos
# perf stat -e cycles garrafas-rum.json
# ESG TIC gflops/watt (by topgree500)
# Medição do consumo de energia
# perf stat -e power/energy garrafas-rum.json}
Lendo tudo isso lembrei de uma citação: “Torture seus dados até que eles confessem o que você deseja comprovar”.
Me desculpa, mas para mim vocês só estão enxugando gelo…
2 curtidas
Penso da mesma forma.
1 curtida
eu tb