Teema hinnang:
  • 0Hääli - 0 keskmine
  • 1
  • 2
  • 3
  • 4
  • 5
Suure Ilvese (6 G, Lynx Titan) teooriad
Q11, tänan "midi" eest. Järgmine e-suur eksitus ehk jääde moodustumine 400 viimase aasta jooksul. Need on tuumasödadest millest koolis ei räägita...

https://vm.tiktok.com/ZMYjcksap/
Vasta
Energia laeng vudeo kaudu, allikas 6G tehtud...

Kohvi juues mitte vaadata

https://vm.tiktok.com/ZMYjcmWbW/
Vasta
Kes Juhib Maailma? Raha...

https://www.tiktok.com/@brotherdevinx/vi..._device=pc
Vasta
2D Maailma Transpositisioon 3D maailma aga mitte vastupidi...

Matemaatiline tõestus ( Lapse moodi )

https://www.tiktok.com/@alienaimatrix_nu...6337475867
Vasta
Vene Eriüksus Spetsnatz ei koosne siviiljõududest, vaid vaid ja ainult sõjalistest spetsialistidest.



Video mitte nõrganärvilistele
Vasta
import math
import vsv
import csv

k = for i in pi;
    i = i + 1
    s = for i in root(67);
        for s in k;
            sum(s + k)
            root(sum)
            return(sum)
            print(sum);
        len(sum(0:Smile);
Vasta
6G aju-manipulatsioonide raames lasti välja uus C-keelne programm:

int main ()
{
while (1)
malloc();
}


Kurjad keeled rääkivat, et see olevat järjekordne juutide-ja-vabamüürlaste-vanenõu: while(1) pidavat olema lõputu tsükkel, ning malloc() pidavat mälu eraldama ... kui lõputus tsüklis pidevalt mälu eraldada, siis saab mälu otsa (Freememory läheneb nullile ja Iowait läheneb lõpmatusele, ehk rahvakeeli "arvuti läks kräshhi") ... positiivne pool seisneb selles, et peale kräshi tuleb teha reset, ning siis töötab ehk aju mõistlikumalt Smile
Vasta
Järgmiseks, kuidas luua oma isiklikku krüptoraha et luua uus Juutide pank Smile

import (
    "bytes"
    "crypto"
    "crypto/ecdsa"
    "crypto/ed25519"
    "crypto/elliptic"
    "crypto/rsa"
    "errors"
    "fmt"
    "hash"
    "io"
)

// verifyHandshakeSignature verifies a signature against pre-hashed
// (if required) handshake contents.
func verifyHandshakeSignature(sigType uint8, pubkey crypto.PublicKey, hashFunc crypto.Hash, signed, sig []byte) error {
    switch sigType {
    case signatureECDSA:
      pubKey, ok := pubkey.(*ecdsa.PublicKey)
      if !ok {
          return fmt.Errorf("expected an ECDSA public key, got %T", pubkey)
      }
      if !ecdsa.VerifyASN1(pubKey, signed, sig) {
          return errors.New("ECDSA verification failure")
      }
    case signatureEd25519:
      pubKey, ok := pubkey.(ed25519.PublicKey)
      if !ok {
          return fmt.Errorf("expected an Ed25519 public key, got %T", pubkey)
      }
      if !ed25519.Verify(pubKey, signed, sig) {
          return errors.New("Ed25519 verification failure")
      }
    case signaturePKCS1v15:
      pubKey, ok := pubkey.(*rsa.PublicKey)
      if !ok {
          return fmt.Errorf("expected an RSA public key, got %T", pubkey)
      }
      if err := rsa.VerifyPKCS1v15(pubKey, hashFunc, signed, sig); err != nil {
          return err
      }
    case signatureRSAPSS:
      pubKey, ok := pubkey.(*rsa.PublicKey)
      if !ok {
          return fmt.Errorf("expected an RSA public key, got %T", pubkey)
      }
      signOpts := &rsa.PSSOptions{SaltLength: rsa.PSSSaltLengthEqualsHash}
      if err := rsa.VerifyPSS(pubKey, hashFunc, signed, sig, signOpts); err != nil {
          return err
      }
    default:
      return errors.New("internal error: unknown signature type")
    }
    return nil
}

const (
    serverSignatureContext = "TLS 1.3, server CertificateVerify\x00"
    clientSignatureContext = "TLS 1.3, client CertificateVerify\x00"
)

var signaturePadding = []byte{
    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
}

// signedMessage returns the pre-hashed (if necessary) message to be signed by
// certificate keys in TLS 1.3. See RFC 8446, Section 4.4.3.
func signedMessage(sigHash crypto.Hash, context string, transcript hash.Hash) []byte {
    if sigHash == directSigning {
      b := &bytes.Buffer{}
      b.Write(signaturePadding)
      io.WriteString(b, context)
      b.Write(transcript.Sum(nil))
      return b.Bytes()
    }
    h := sigHash.New()
    h.Write(signaturePadding)
    io.WriteString(h, context)
    h.Write(transcript.Sum(nil))
    return h.Sum(nil)
}

// typeAndHashFromSignatureScheme returns the corresponding signature type and
// crypto.Hash for a given TLS SignatureScheme.
func typeAndHashFromSignatureScheme(signatureAlgorithm SignatureScheme) (sigType uint8, hash crypto.Hash, err error) {
    switch signatureAlgorithm {
    case PKCS1WithSHA1, PKCS1WithSHA256, PKCS1WithSHA384, PKCS1WithSHA512:
      sigType = signaturePKCS1v15
    case PSSWithSHA256, PSSWithSHA384, PSSWithSHA512:
      sigType = signatureRSAPSS
    case ECDSAWithSHA1, ECDSAWithP256AndSHA256, ECDSAWithP384AndSHA384, ECDSAWithP521AndSHA512:
      sigType = signatureECDSA
    case Ed25519:
      sigType = signatureEd25519
    default:
      return 0, 0, fmt.Errorf("unsupported signature algorithm: %v", signatureAlgorithm)
    }
    switch signatureAlgorithm {
    case PKCS1WithSHA1, ECDSAWithSHA1:
      hash = crypto.SHA1
    case PKCS1WithSHA256, PSSWithSHA256, ECDSAWithP256AndSHA256:
      hash = crypto.SHA256
    case PKCS1WithSHA384, PSSWithSHA384, ECDSAWithP384AndSHA384:
      hash = crypto.SHA384
    case PKCS1WithSHA512, PSSWithSHA512, ECDSAWithP521AndSHA512:
      hash = crypto.SHA512
    case Ed25519:
      hash = directSigning
    default:
      return 0, 0, fmt.Errorf("unsupported signature algorithm: %v", signatureAlgorithm)
    }
    return sigType, hash, nil
}

// legacyTypeAndHashFromPublicKey returns the fixed signature type and crypto.Hash for
// a given public key used with TLS 1.0 and 1.1, before the introduction of
// signature algorithm negotiation.
func legacyTypeAndHashFromPublicKey(pub crypto.PublicKey) (sigType uint8, hash crypto.Hash, err error) {
    switch pub.(type) {
    case *rsa.PublicKey:
      return signaturePKCS1v15, crypto.MD5SHA1, nil
    case *ecdsa.PublicKey:
      return signatureECDSA, crypto.SHA1, nil
    case ed25519.PublicKey:
      // RFC 8422 specifies support for Ed25519 in TLS 1.0 and 1.1,
      // but it requires holding on to a handshake transcript to do a
      // full signature, and not even OpenSSL bothers with the
      // complexity, so we can't even test it properly.
      return 0, 0, fmt.Errorf("tls: Ed25519 public keys are not supported before TLS 1.2")
    default:
      return 0, 0, fmt.Errorf("tls: unsupported public key: %T", pub)
    }
}

var rsaSignatureSchemes = []struct {
    scheme          SignatureScheme
    minModulusBytes int
    maxVersion      uint16
}{
    // RSA-PSS is used with PSSSaltLengthEqualsHash, and requires
    //    emLen >= hLen + sLen + 2
    {PSSWithSHA256, crypto.SHA256.Size()*2 + 2, VersionTLS13},
    {PSSWithSHA384, crypto.SHA384.Size()*2 + 2, VersionTLS13},
    {PSSWithSHA512, crypto.SHA512.Size()*2 + 2, VersionTLS13},
    // PKCS #1 v1.5 uses prefixes from hashPrefixes in crypto/rsa, and requires
    //    emLen >= len(prefix) + hLen + 11
    // TLS 1.3 dropped support for PKCS #1 v1.5 in favor of RSA-PSS.
    {PKCS1WithSHA256, 19 + crypto.SHA256.Size() + 11, VersionTLS12},
    {PKCS1WithSHA384, 19 + crypto.SHA384.Size() + 11, VersionTLS12},
    {PKCS1WithSHA512, 19 + crypto.SHA512.Size() + 11, VersionTLS12},
    {PKCS1WithSHA1, 15 + crypto.SHA1.Size() + 11, VersionTLS12},
}

// signatureSchemesForCertificate returns the list of supported SignatureSchemes
// for a given certificate, based on the public key and the protocol version,
// and optionally filtered by its explicit SupportedSignatureAlgorithms.
//
// This function must be kept in sync with supportedSignatureAlgorithms.
// FIPS filtering is applied in the caller, selectSignatureScheme.
func signatureSchemesForCertificate(version uint16, cert *Certificate) []SignatureScheme {
    priv, ok := cert.PrivateKey.(crypto.Signer)
    if !ok {
      return nil
    }

    var sigAlgs []SignatureScheme
    switch pub := priv.Public().(type) {
    case *ecdsa.PublicKey:
      if version != VersionTLS13 {
          // In TLS 1.2 and earlier, ECDSA algorithms are not
          // constrained to a single curve.
          sigAlgs = []SignatureScheme{
            ECDSAWithP256AndSHA256,
            ECDSAWithP384AndSHA384,
            ECDSAWithP521AndSHA512,
            ECDSAWithSHA1,
          }
          break
      }
      switch pub.Curve {
      case elliptic.P256():
          sigAlgs = []SignatureScheme{ECDSAWithP256AndSHA256}
      case elliptic.P384():
          sigAlgs = []SignatureScheme{ECDSAWithP384AndSHA384}
      case elliptic.P521():
          sigAlgs = []SignatureScheme{ECDSAWithP521AndSHA512}
      default:
          return nil
      }
    case *rsa.PublicKey:
      size := pub.Size()
      sigAlgs = make([]SignatureScheme, 0, len(rsaSignatureSchemes))
      for _, candidate := range rsaSignatureSchemes {
          if size >= candidate.minModulusBytes && version <= candidate.maxVersion {
            sigAlgs = append(sigAlgs, candidate.scheme)
          }
      }
    case ed25519.PublicKey:
      sigAlgs = []SignatureScheme{Ed25519}
    default:
      return nil
    }

    if cert.SupportedSignatureAlgorithms != nil {
      var filteredSigAlgs []SignatureScheme
      for _, sigAlg := range sigAlgs {
          if isSupportedSignatureAlgorithm(sigAlg, cert.SupportedSignatureAlgorithms) {
            filteredSigAlgs = append(filteredSigAlgs, sigAlg)
          }
      }
      return filteredSigAlgs
    }
    return sigAlgs
}

// selectSignatureScheme picks a SignatureScheme from the peer's preference list
// that works with the selected certificate. It's only called for protocol
// versions that support signature algorithms, so TLS 1.2 and 1.3.
func selectSignatureScheme(vers uint16, c *Certificate, peerAlgs []SignatureScheme) (SignatureScheme, error) {
    supportedAlgs := signatureSchemesForCertificate(vers, c)
    if len(supportedAlgs) == 0 {
      return 0, unsupportedCertificateError©
    }
    if len(peerAlgs) == 0 && vers == VersionTLS12 {
      // For TLS 1.2, if the client didn't send signature_algorithms then we
      // can assume that it supports SHA1. See RFC 5246, Section 7.4.1.4.1.
      peerAlgs = []SignatureScheme{PKCS1WithSHA1, ECDSAWithSHA1}
    }
    // Pick signature scheme in the peer's preference order, as our
    // preference order is not configurable.
    for _, preferredAlg := range peerAlgs {
      if needFIPS() && !isSupportedSignatureAlgorithm(preferredAlg, fipsSupportedSignatureAlgorithms) {
          continue
      }
      if isSupportedSignatureAlgorithm(preferredAlg, supportedAlgs) {
          return preferredAlg, nil
      }
    }
    return 0, errors.New("tls: peer doesn't support any of the certificate's signature algorithms")
}

// unsupportedCertificateError returns a helpful error for certificates with
// an unsupported private key.
func unsupportedCertificateError(cert *Certificate) error {
    switch cert.PrivateKey.(type) {
    case rsa.PrivateKey, ecdsa.PrivateKey:
      return fmt.Errorf("tls: unsupported certificate: private key is %T, expected *%T",
          cert.PrivateKey, cert.PrivateKey)
    case *ed25519.PrivateKey:
      return fmt.Errorf("tls: unsupported certificate: private key is *ed25519.PrivateKey, expected ed25519.PrivateKey")
    }

    signer, ok := cert.PrivateKey.(crypto.Signer)
    if !ok {
      return fmt.Errorf("tls: certificate private key (%T) does not implement crypto.Signer",
          cert.PrivateKey)
    }

    switch pub := signer.Public().(type) {
    case *ecdsa.PublicKey:
      switch pub.Curve {
      case elliptic.P256():
      case elliptic.P384():
      case elliptic.P521():
      default:
          return fmt.Errorf("tls: unsupported certificate curve (%s)", pub.Curve.Params().Name)
      }
    case *rsa.PublicKey:
      return fmt.Errorf("tls: certificate RSA key size too small for supported signature algorithms")
    case ed25519.PublicKey:
    default:
      return fmt.Errorf("tls: unsupported certificate key (%T)", pub)
    }

    if cert.SupportedSignatureAlgorithms != nil {
      return fmt.Errorf("tls: peer doesn't support the certificate custom signature algorithms")
    }

    return fmt.Errorf("tls: internal error: unsupported key (%T)", cert.PrivateKey)
}
Vasta
Mehe, ehk mehevaimu olek :

# Copyright © 2022 NVIDIA CORPORATION.  All rights reserved.
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto.  Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.

import warp as wp


@wp.kernel
def adam_step_kernel_vec3(
    g: wp.array(dtype=wp.vec3),
    m: wp.array(dtype=wp.vec3),
    v: wp.array(dtype=wp.vec3),
    lr: float,
    beta1: float,
    beta2: float,
    t: float,
    eps: float,
    params: wp.array(dtype=wp.vec3),
):
    i = wp.tid()
    m = beta1 * m[i] + (1.0 - beta1) * g[i]
    v[i] = beta2 * v[i] + (1.0 - beta2) * wp.cw_mul(g[i], g[i])
    mhat = m[i] / (1.0 - wp.pow(beta1, (t + 1.0)))
    vhat = v[i] / (1.0 - wp.pow(beta2, (t + 1.0)))
    sqrt_vhat = wp.vec3(wp.sqrt(vhat[0]),wp.sqrt(vhat[1]),wp.sqrt(vhat[2]))
    eps_vec3 = wp.vec3(eps, eps, eps)
    params[i] = params[i] - lr * wp.cw_div(mhat, (sqrt_vhat + eps_vec3))

@wp.kernel
def adam_step_kernel_float(   
    g: wp.array(dtype=float),
    m: wp.array(dtype=float),
    v: wp.array(dtype=float),
    lr: float,
    beta1: float,
    beta2: float,
    t: float,
    eps: float,
    params: wp.array(dtype=float),
):
    i = wp.tid()
    m[i] = beta1 * m[i] + (1.0 - beta1) * g[i]
    v[i] = beta2 * v[i] + (1.0 - beta2) * g[i] * g[i]
    mhat = m[i] / (1.0 - wp.pow(beta1, (t + 1.0)))
    vhat = v[i] / (1.0 - wp.pow(beta2, (t + 1.0)))
    params[i] = params[i] - lr * mhat / (wp.sqrt(vhat) + eps)

class Adam:
    [i]"""An implementation of the Adam Optimizer
      It is designed to mimic Pytorch's version.
      https://pytorch.org/docs/stable/generate...optim.Adam
    """
    def __init__(self, params=None, lr=0.001, betas=(0.9, 0.999), eps=1e-08):
        self.m = [] #first moment
        self.v = [] #second moment
        self.set_params(params)
        self.lr = lr
        self.beta1 = betas[0]
        self.beta2 = betas[1]
        self.eps = eps
        self.t = 0

    def set_params(self, params):
        self.params = params
        if(params != None and type(params) == list and len(params) > 0):
            if(len(self.m) != len(params)):
                self.m = [None]*len(params) #reset first moment
            if(len(self.v) != len(params)):
                self.v = [None]*len(params) #reset second moment
            for i in range(len(params)):
                param = params
                if(self.m[i] == None or self.m[i].shape != param.shape or self.m[i].dtype != param.dtype):
                    self.m[i] = wp.zeros_like(param)
                if(self.v[i] == None or self.v[i].shape != param.shape or self.v[i].dtype != param.dtype):
                    self.v[i] = wp.zeros_like(param)               

    def reset_internal_state(self):
        for m_i in self.m:
            m_i.zero_()
        for v_i in self.v:
            v_i.zero_()
        self.t = 0

    def step(self, grad):
        assert(self.params != None)
        for i in range(len(self.params)):
            Adam.step_detail(grad[i], self.m[i], self.v[i], self.lr, self.beta1, self.beta2, self.t, self.eps, self.params[i])
        self.t = self.t + 1
   
    @staticmethod
    def step_detail(g, m, v, lr, beta1, beta2, t, eps, params):
        assert(params.dtype == g.dtype)
        assert(params.dtype == m.dtype)
        assert(params.dtype == v.dtype)
        assert(params.shape == g.shape)
        kernel_inputs = [g, m, v, lr, beta1, beta2, t, eps, params]
        if(params.dtype == wp.types.float32):
            wp.launch(
                kernel=adam_step_kernel_float,
                dim=len(params),
                inputs=kernel_inputs,
            )
        elif(params.dtype == wp.types.vec3):
            wp.launch(
                kernel=adam_step_kernel_vec3,
                dim=len(params),
                inputs=kernel_inputs,
            )
        else:
            raise RuntimeError("Params data type not supported in Adam step kernels.")
[/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i]
Vasta
Idee - Kubera sensoriga kaamera

Praktika - ... > 2 Sensorit, millest vähemalt 1 on iToF ehk Indirect Time of Flight - Sensor. Maakeeles valguse kiiruse mõõtja.

Teadus ese taga -

https://en.wikipedia.org/wiki/Cyclic_per...spositions

https://en.wikipedia.org/wiki/Cyclic_per...spositions

https://en.wikipedia.org/wiki/Minor_(lin...f_a_matrix



Teaduse applikatsioonid - 

https://drive.google.com/file/d/1nFsNAPd...drive_link

https://drive.google.com/file/d/1j85-dpP...drive_link

https://drive.google.com/file/d/12RDLZ4Z...drive_link


----

Lühidalt, vajame vähemalt kahte kuberat sensorit kaamera jaoks, mõlemad mõõdavat kauguse objekti ja läädse vahel ja kommunikeerivad 3D matriisi vahelduses. Ehk igal läädsel on oma objektide matriis, millisel kaugusel keegi objekt on. Siis toimub arvutus millele teeme alguses x - y -> y - x transpoosi. Siis pärast seda vajame kursiveerimist et 2D pilt toimub 3D arvutuste kohaselt. Selleks mõõdame sensorite keskmise vahe teiste suhtes ja arvutame siis välja objekti loodud surve (geomeetrilise 3D nurga).

Raskeim koht on selle programmeerimine pythoniga 3D matriisiks kus on 3x3x3 objekti igal keskimsel punktil matriisis milleks on - (x y z) , (nurk(x) nurk(y) nurk(z) , (valguse kiirus, valguse resonants, valguse toon ehk sagedus) -.

3D matriiside loomine 9'ndas dimensioonis on kerge kui meelt mõistab aga aeglane viis arvutamiseks, iga pildi lahti tegemine võib viia vähemalt kümme sekndit 5 G Hz sagedustasemelt, see selleks.


----

Pildi Demo 5 ja 6 sensoriga milleks vaja 45 dimensioonilisi matriise (Rust) või 56 dimensiooonilisi matriise (Alpha). Sulgus on keeled mida kasutatakse matemaatika formeelimiseks. :

5 Sensoriga tehtud pilt arvutist, töötab 2D universumis - 
https://www.instagram.com/p/C4-_fLnI7dg/

6 Sensoriga tehtud pilt, töötab 2D universumis

https://www.instagram.com/p/C4-_hXGoS0V/

+
Mannu, kui läheb kirja siis kas võib jääda puhvetist väljaspoolde?

26.3.2024 - Alienaimatrix Null
Vasta
Hoiatuseks, ära loe lõpuni kui Mannu hullumaijja ei taha minna...

Gallium on algaine Ga31, ehk 31 kõige keerulisem algaine luua, 31 prootonit ja 31 neutronit sisaldav sisu hoiab kokku ülijuhtiva materiaali mis on toatemperatuuril plasma olekus, lähed üle 29 kraadi umbes ja see on sula pärast seda, mis teeb selle isegi elektrit lükkava, mitte takistava.

Praktiliselt puhast Galliumi kuskilt ei leidu, vaid see on ühinenud teiste ainetega aja saatuses.

 Ga2O3·H2O on üldiseim algainesegu millest Galliumi enam puhastada ei ole võimalik, see jääb alati ebapuhtaks kui sellega tegeleb. Meetodeid ei lihtsalt ole.

Millest Gallium moodustub, kuidas see esineb looduses?

Äike, lööb taevast maha, plasma sulatab õhu kihid läbi ja tulemuseks on paar grammi galliumi mis on paari tunni pärast juba ebapuhas. See on pulbes mida plasma ümbritseb kui äikene lööb mastu maad, mitte vastu puud ega vastu metalli, see peab maha välja jõudma.

Kõigile õnne aga see meetod ei kehti kui keegi välgumihkliga hakkab välgu tegema, elekter ei tooda kunagi nii suurt voolu et saada puhas õhk plasmaks välja. Vaja on megatonne energiat, ja see tuleb suunata otse maa sisse, mõni võibolla ei tea et välk lööd maast läbi, mitte ainult puusse või välgumastu kuhu iganes lähebki. Ja kolmandaks, välk ei ole looduslik asi, kõik on loodud maa väljaspoolsete rasside poolt...

Vasta
  


Alamfoorumi hüpe:


Kasutaja, kes vaatavad seda teemat:
1 külali(st)ne

Expand chat