;(function() { window.createMeasureObserver = (measureName) => { var markPrefix = `_uol-measure-${measureName}-${new Date().getTime()}`; performance.mark(`${markPrefix}-start`); return { end: function() { performance.mark(`${markPrefix}-end`); performance.measure(`uol-measure-${measureName}`, `${markPrefix}-start`, `${markPrefix}-end`); performance.clearMarks(`${markPrefix}-start`); performance.clearMarks(`${markPrefix}-end`); } } }; /** * Gerenciador de eventos */ window.gevent = { stack: [], RUN_ONCE: true, on: function(name, callback, once) { this.stack.push([name, callback, !!once]); }, emit: function(name, args) { for (var i = this.stack.length, item; i--;) { item = this.stack[i]; if (item[0] === name) { item[1](args); if (item[2]) { this.stack.splice(i, 1); } } } } }; var runningSearch = false; var hadAnEvent = true; var elementsToWatch = window.elementsToWatch = new Map(); var innerHeight = window.innerHeight; // timestamp da última rodada do requestAnimationFrame // É usado para limitar a procura por elementos visíveis. var lastAnimationTS = 0; // verifica se elemento está no viewport do usuário var isElementInViewport = function(el) { var rect = el.getBoundingClientRect(); var clientHeight = window.innerHeight || document.documentElement.clientHeight; // renderizando antes, evitando troca de conteúdo visível no chartbeat-related-content if(el.className.includes('related-content-front')) return true; // garante que usa ao mínimo 280px de margem para fazer o lazyload var margin = clientHeight + Math.max(280, clientHeight * 0.2); // se a base do componente está acima da altura da tela do usuário, está oculto if(rect.bottom < 0 && rect.bottom > margin * -1) { return false; } // se o topo do elemento está abaixo da altura da tela do usuário, está oculto if(rect.top > margin) { return false; } // se a posição do topo é negativa, verifica se a altura dele ainda // compensa o que já foi scrollado if(rect.top < 0 && rect.height + rect.top < 0) { return false; } return true; }; var asynxNextFreeTime = () => { return new Promise((resolve) => { if(window.requestIdleCallback) { window.requestIdleCallback(resolve, { timeout: 5000, }); } else { window.requestAnimationFrame(resolve); } }); }; var asyncValidateIfElIsInViewPort = function(promise, el) { return promise.then(() => { if(el) { if(isElementInViewport(el) == true) { const cb = elementsToWatch.get(el); // remove da lista para não ser disparado novamente elementsToWatch.delete(el); cb(); } } }).then(asynxNextFreeTime); }; // inicia o fluxo de procura de elementos procurados var look = function() { if(window.requestIdleCallback) { window.requestIdleCallback(findByVisibleElements, { timeout: 5000, }); } else { window.requestAnimationFrame(findByVisibleElements); } }; var findByVisibleElements = function(ts) { var elapsedSinceLast = ts - lastAnimationTS; // se não teve nenhum evento que possa alterar a página if(hadAnEvent == false) { return look(); } if(elementsToWatch.size == 0) { return look(); } if(runningSearch == true) { return look(); } // procura por elementos visíveis apenas 5x/seg if(elapsedSinceLast < 1000/5) { return look(); } // atualiza o último ts lastAnimationTS = ts; // reseta status de scroll para não entrar novamente aqui hadAnEvent = false; // indica que está rodando a procura por elementos no viewport runningSearch = true; const done = Array.from(elementsToWatch.keys()).reduce(asyncValidateIfElIsInViewPort, Promise.resolve()); // obtém todos os elementos que podem ter view contabilizados //elementsToWatch.forEach(function(cb, el) { // if(isElementInViewport(el) == true) { // // remove da lista para não ser disparado novamente // elementsToWatch.delete(el); // cb(el); // } //}); done.then(function() { runningSearch = false; }); // reinicia o fluxo de procura look(); }; /** * Quando o elemento `el` entrar no viewport (-20%), cb será disparado. */ window.lazyload = function(el, cb) { if(el.nodeType != Node.ELEMENT_NODE) { throw new Error("element parameter should be a Element Node"); } if(typeof cb !== 'function') { throw new Error("callback parameter should be a Function"); } elementsToWatch.set(el, cb); } var setEvent = function() { hadAnEvent = true; }; window.addEventListener('scroll', setEvent, { capture: true, ive: true }); window.addEventListener('click', setEvent, { ive: true }); window.addEventListener('resize', setEvent, { ive: true }); window.addEventListener('load', setEvent, { once: true, ive: true }); window.addEventListener('DOMContentLoaded', setEvent, { once: true, ive: true }); window.gevent.on('allJSLoadedAndCreated', setEvent, window.gevent.RUN_ONCE); // inicia a validação look(); })();
  • AssineUOL
Topo

Processador Eagle: como funciona o computador quântico mais avançado da IBM

O novo processador Eagle, da IBM, superior a capacidade do anterior, o Hummingbird - IBM
O novo processador Eagle, da IBM, superior a capacidade do anterior, o Hummingbird Imagem: IBM

18/11/2021 12h24

A IBM anunciou que seu novo processador quântico - que usa propriedades da física quântica para fazer cálculos - ultraou o limite de processamento existente em máquinas.

A IBM anunciou nesta semana a criação de um processador quântico avançado, batizado de Eagle (águia, em inglês).

Processadores quânticos podem revolucionar a computação ao usar propriedades das partículas da física quântica para fazer cálculos, superando em muito a capacidade de processamento dos processadores convencionais, que usam linguagem binária.

No entanto, dificuldades na construção de versões práticas de computadores quânticos em grande escala mantinham a ideia restrita a experimentos de laboratório.

O novo processador desenvolvido pela IBM tem 127 "qubits", o dobro do dispositivo da IBM anterior. "Qubits" são as unidades mais básicas de informação em um computador quântico — análogos aos "bits" em computadores normais, mas muito mais potentes.

A empresa disse que seu novo processador Eagle é "um marco importante no caminho para a computação quântica prática".

Detalhes não revelados

Mas o professor Scott Aaronson, especialista em computação quântica da Universidade do Texas em Austin, disse que mais detalhes são necessários para avaliar se isso representa um avanço significativo.

"Estou ansioso para ver os detalhes", disse Aaronson em seu blog.

O especialista em computação quântica acrescentou que as informações divulgadas até agora pela IBM não revelam parâmetros-chave que normalmente se usa para avaliar o progresso da computação quântica.

Em 2016, a IBM foi a primeira empresa a disponibilizar a computação quântica na nuvem, abrindo o às máquinas para mais usuários.

Como funciona um computador quântico

Nos últimos anos, houve um aumento no interesse sobre esse tipo de máquina devido ao seu potencial para melhorar enormemente o poder de computação da humanidade.

Os computadores quânticos exploram as propriedades da matéria em suas menor escala, ou seja, usam propriedades físicas das partículas subatômicas.

Em computadores tradicionais, a unidade de informação é chamada de "bit" e pode ter um valor de um ou zero.

Seu equivalente em um sistema quântico — o qubit — pode ser um e zero ao mesmo tempo.

Este é o conceito de superposição da mecânica quântica, onde uma partícula pode existir em vários estados ao mesmo tempo.

Com uma capacidade de processamento muito maior, computadores do tipo podem ser usados para ajudar a desenvolver novos materiais e medicamentos ou melhorar aspectos da inteligência artificial.

Supremacia quântica

Um o importante nesse desenvolvimento é demonstrar o que foi apelidado de "supremacia quântica" — a capacidade de resolver problemas que computadores convencionais não conseguiriam resolver.

Em 2019, o Google disse que seu processador quântico Sycamore, de 53 "qubits", ultraou o desempenho de um computador convencional em uma tarefa específica pela primeira vez.

Os pesquisadores do Google publicaram os resultados na prestigiosa revista acadêmica Nature.

Na época, cientistas da IBM questionaram alguns dos números do Google e sua definição de supremacia quântica. Detalhes sobre o novo desenvolvimento da IBM ainda serão publicados.