[Lynx Titan]

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/

[Lynx Titan]

Energia laeng vudeo kaudu, allikas 6G tehtud...

Kohvi juues mitte vaadata

https://vm.tiktok.com/ZMYjcmWbW/

[Lynx Titan]

Kes Juhib Maailma? Raha...

https://www.tiktok.com/@brotherdevinx/vi..._device=pc

[Lynx Titan]

2D Maailma Transpositisioon 3D maailma aga mitte vastupidi...

Matemaatiline tõestus ( Lapse moodi )

https://www.tiktok.com/@alienaimatrix_nu...6337475867

[Lynx Titan]

Teen teadusliku postituse, ise tehtud nagu ise, kah  ei ma mõtlen et ise tehtud teadlik teaduslik postitus, aa ma mõtlesin nüüd et kirjutad teaduslik teadusuuring aga jätsin selle ära, teadlikult

Maksimaalne Helisurv e on 154,2 dB. 

Milleks? Sest heli teeb ilma pehmeks ja rohkem ei anna, tuleb maksimum vastu, ei räägi poest üldse

Siin tõendid.

Arvuti = 252 GHz
Sub Woofer = 4 x 5,5" + 4 x 3,3" = 1,55 MW = 155 000 000 W

Arvutused on tehtud temperatuuril 0 kraadi, tegelt oli kyll 21 kraadi aga mul poh gui, ei saa kiruda ju

Enam vähem läks 15 MW, kuna temperatuurne helitakisti on logaritmiline.

Katse kestis kaks tundi, ehk raha kulus, oota. Hind 15 euriku senti kW/h pääle siis ongi:

15 * 2 * 15 000 000 = 450 000 000 €

Riik maksis sest mul 112 Kela maksis tegelt okei ütlen otseselt,

Tsau

Video, pange volüüm madalaks

Volüüm madalaks okei

[Lynx Titan]

Siin Tehisintellekti Arvamus palju võimsust kulus, juudi matemaatikaga :

Tere! Tänan, et küsisite minult abi.
Selleks, et arvutada vajalik võimsus, mis on vajalik 154,2 dB helirõhu saavutamiseks 91 dB tundlikkuse ja 21 °C toatemperatuuri juures, peame kasutama heli võimsuse valemit:
Lp​=Lw​+10log10​(Q)
kus Lp​ on helirõhk, Lw​ on helivõimsus ja Q on heli kvaliteegifaktor.
Kuna meil on olemas helirõhk ja tundlikkus, saame helivõimsuse leidmiseks kasutada järgmist valemit:
Lw​=Lp​−10log10​(Q1​)
Kui me eeldame, et heli kvaliteegifaktor on 1, siis saame arvutada vajaliku helivõimsuse järgmiselt:
Lw​=154,2−91+10log10​(11​)=63,2dB
Nüüd, kui me teame helivõimsust, saame arvutada vajaliku võimsuse, kasutades järgmist valemit:
P=10Lw​​+1=7,94W
Seega on vajalik võimsus, mis on vajalik 154,2 dB helirõhu saavutamiseks 91 dB tundlikkuse ja 21 °C toatemperatuuri juures, umbes 7,94 W 12.
Loodan, et see vastus oli teile abiks. Kui teil on veel küsimusi, siis andke mulle sellest teada!

- See oleks siis kui Matrixit ei oleks

[Lynx Titan]

Muidugi, ma saan aidata. Kui ma õigesti aru saan, siis soovite teada, kui palju ampreid on vaja, et toota 15 MW võimsust. Võimsus, vool ja pinge on omavahel seotud järgmise valemi abil: P = V × I, kus P tähistab võimsust vattides, V tähistab pinget voltides ja I tähistab voolutugevust amprites. Kui me teame võimsust ja pinget, siis saame arvutada voolutugevuse järgmise valemi abil: I = P / V.

Kuna te soovite teada, kui palju ampreid on vaja, et toota 15 MW võimsust, siis peame kõigepealt arvutama pinget. Kui me eeldame, et kasutame 3-faasilist voolu, siis saame arvutada pinget järgmise valemi abil: P = √3 × V × I × cos(φ), kus φ tähistab faasinihet. Kui me eeldame, et faasinihet on 0, siis saame valemi järgmiselt ümber kirjutada: V = P / (√3 × I).

Nüüd saame arvutada pinget järgmise valemi abil: V = 15 000 000 W / (√3 × I). Kui me eeldame, et kasutame 480-voldist toiteallikat, siis saame arvutada voolutugevuse järgmise valemi abil: I = P / (V × √3). Seega, kui kasutame 480-voldist toiteallikat, siis on vaja 28 846 amprit .

Loodan, et see vastus oli teile abiks. Kui teil on veel küsimusi, siis andke mulle teada.

[Lynx Titan]

Vene Eriüksus Spetsnatz ei koosne siviiljõududest, vaid vaid ja ainult sõjalistest spetsialistidest.



Video mitte nõrganärvilistele

[Lynx Titan]

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:);

[lahendused]

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

[Lynx Titan]

Järgmiseks, kuidas luua oma isiklikku krüptoraha et luua uus Juutide pank

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)
}

[Lynx Titan]

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]

[Lynx Titan]

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

[Lynx Titan]

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...

[Lynx Titan]

Ma Saan Aru, mida sa mõtled, kuigi Telepaatia on endiselt ulme mõiste, oni tõsi et paljud inimesed kogevad üksteistega tugevaid sidemein ja intuitiivseid arusaamu. Seda võiks nimetada omamoodi sotsiaalseks telepaatiaks või "emotionaalseks telepaatiaks", neid umbes alla 2%. Mis on osa suhtelmist ja inimesevahelist suhtlust ja empaatiast arusaamist.

Maatriks on matemaatiline kontseptisoon mis kasutattakse laialdaselt erinevates teadusvaldkondades nagu füüsika ja arvutiteadus ja tehisintellekt. See on järjestatud numbrite sümbolite komplekt, mis on paigutatud ridadesse ja veergudesse. Matriiksid saab kasutada mitlem otstarbel, näiteks andmete esitamiseks, teisendamiseks ja aruvtusteks.

Kuidas oleks Matriiks seotus fPGP ja "sotsiaalse telepaatiaga"?

Võime ette kujutada hüpoteetilist StSenaariumi, kus;

Sotsiaalne telepaatia:

Inimesed saavad krüpteerimisvõtmeid või muud salajast jagada teaved üksteistega intuitiivselt, või ilma füüsilise kontakti või elektroonilise suhtluse kaudu. 

Maatriks:

Selle intuitiivse suhtluse modelleerimiseks ja analüüsimiseks kasutatakse maatrikseid. Näiteks võiksid maatriksid kirjeldada inimestevahelisi seoseid, võtmete jaotust või isegi mõtete ja tunnete matemaatilist esitust.

Väljakutsed ja Võimalused:

V'ljakutsed: Selline mudel oleks väga keeruline ja võuaks nii inimmõistuse kui matemaatiliste mudelite sügavad mõistmist. Võimalused, kui selline mudel oleks võimalik, võib see muuta krüpteerimistehnoloogia pöörde ja võimaldada täiesti uusi viise turvaliseks suhtlemiseks ja teave jagamiseks.

Tuleviku Väljavaateid:

Oluline on märkida et see on endiselt väga spekulatiivne ja teoreetiline mõtlemine. Me ei tea, kas sotsiaalne telepaatia on tegelikult igale võimalik või kuidas seda krüptograafias ära kasutada.

Teaduse ja tehnoloogia arenduse edusammudel on aga võimalik, et uusi viise tulevikus leiame ja sotsiaalse suhtluse keerukuse mõistmiseks ja kasutamiseks see on hea. See võib avada uksed täiesti uutele tehnoloogiatele, mida me veel ettegi ei kujuta.

[Lynx Titan]

[Lynx Titan]

Absoluutselt! Siin on topoloogilised juhised fPGP (Forced Pretty Good Protection) kontseptuaalse raamistikuga töötamiseks õpingutes, pidades silmas selle teoreetilist olemust:

Topoloogilised juhised fPGP jaoks uuringutes:

Sihtasutus:

fPGP Core: mõistke päris hea privaatsuse (PGP) aluspõhimõtteid, sealhulgas avaliku võtmega krüptograafiat, krüptimist/dekrüpteerimist ja digitaalallkirju. Saate aru, kuidas fPGP laiendab neid mõisteid, keskendudes sundkaitsemehhanismidele.
Maatriksioperatsioonid: tutvuge põhiliste maatriksitoimingutega, nagu liitmine, korrutamine ja inversioon. Uurige, kuidas maatriksid võivad kujutada teavet ja teisendusi.

Ühendused:

Võtmete genereerimine: saate aru, kuidas fPGP kasutab krüptograafiliste võtmete loomiseks maatriksiteisendusi (nt juhuslikku maatriksi genereerimist, maatriksi korrutamist). Uurige selle lähenemisviisi võimalikke eeliseid turvalisuse ja keerukuse osas.
Krüpteerimine/dekrüpteerimine: uurige, kuidas saaks maatriksoperatsioone integreerida fPGP krüpteerimis- ja dekrüpteerimisprotsessidesse. Uurige potentsiaalseid algoritme ja nende mõju turvalisusele.
Telepaatia (teoreetiline): sukelduge telepaatia spekulatiivsesse valdkonda. Uurige, kuidas saaks telepaatilist suhtlust (kui võimalik) esitada maatriksite abil ja kuidas seda fPGP-sse võtme vahetamiseks või autentimiseks lisada. Mõelge selle kontseptsiooni eetilistele tagajärgedele.


Rakendused:

Uurimistööd: kirjutage fPGP teoreetilist raamistikku uurivaid uurimistöid. Analüüsige selle võimalikke eeliseid, piiranguid ja eetilisi kaalutlusi.
Simulatsioonid: maatriksipõhise fPGP teostatavuse ja tõhususe testimiseks töötage välja simulatsioonid või mudelid. Katsetage erinevate maatriksoperatsioonide ja parameetritega, et hinnata nende mõju turvalisusele.
Ettekanded: esitlege oma tulemusi klassikaaslastele või akadeemilistel konverentsidel. Arutage fPGP võimalikke reaalmaailma rakendusi ja selle rakendamisega kaasnevaid väljakutseid.

Laiendused:

Täiustatud matemaatika: süvenege fPGP jaoks olulistesse täiustatud matemaatikakontseptsioonidesse, nagu moodularitmeetika, lineaaralgebra ja arvuteooria.
Krüptoprotokollid: uurige olemasolevaid krüptoprotokolle ja uurige, kuidas saaks fPGP-d nendega turvalisuse suurendamiseks integreerida.
Interdistsiplinaarsed uuringud: uurige fPGP ja neuroteaduse, psühholoogia ja eetika ristumisvõimalusi, et mõista telepaatial põhineva suhtluse võimalikke tagajärgi.

Olulised kaalutlused:

Teoreetiline olemus: rõhutage, et fPGP, eriti telepaatia aspekt, on puhtalt teoreetiline ja spekulatiivne.
Eetilised kaalutlused: käsitlege alati telepaatia eetilisi tagajärgi ja võimalikke privaatsusprobleeme.
Teaduslik rangus: tuginege oma õpingutes usaldusväärsetele teaduslikele põhimõtetele ja metoodikatele.
Kriitiline mõtlemine: hinnake fPGP kontseptsioonide teostatavust ja praktilisust kriitilise objektiiviga.
Loodan, et see topoloogiline raamistik pakub struktureeritud lähenemisviisi fPGP kaasamiseks teie uuringutesse. Andke mulle teada, kui teil on konkreetseid küsimusi või soovite teatud aspekte üksikasjalikumalt uurida!

[Lynx Titan]

Heli on elektromagneetiline kiirgus, sagedus. Nüüd lähevad kõik õpikud uuesti printi, tsau kõigile kes raamatuid prindivad

[Lynx Titan]

Maja levib ja vaja jälle toitu hakata tegema, katus pea pael veel, peal siis

Tänane puhveti and ehk hullumaja teooria üksinda või üksilduses

a = 0
b = 1
c = 3
d = f - [i]
e = -3
g = 36
f = 7
h = 71
j = 8
k = lm + 1
l = AI
m = 71 + 0
n = 9
o = 1 + 01
p = 7
r = s
s = t
t = kl
v = 71
u = 1 + 0
ü = 89 - 1
õ = 1

[Lynx Titan]

6:33
Mannule, palun pea sellest teooriast hoolt, kõige tähtsam teooria foorumil - MP 2024
Teooria nimi on musta palli teooria
See kujutab endas silma palle, mis on teiste sees, palli sees on pall ja need on samasugused, eksju. Kui pall on suurem kui teine, sellel pole vahet, pall on ikkagi palli sees, 1:1.
Mida teooria siia puutub on see, et väikene pall ei ole kunagi niin suur kui suur pall, ja seda läheme siia tõestama, 1:1
Kasutusele, geomeetria, hexograafia, ja topoloogia
Formaal :
x = x0 + sin(r(θ))(cos(φ))
y = y0 + sin(r(θ))(sin(φ))
z = z0 + cos(r(θ))
x^2 - y^2 - z^2 - (ict)^2 = 0
i = pi
c = λ * Hz
θ = 360
φ = 360
r = s/pi
Lahendame s ehk plancki aja määre.

s= arcsin((x - x0) * π / cos(φ)) / θ
s = arcsin((y - x0) * π / sin(φ)) / θ
s = arccos(z - x0) * π / θ

Sistestame universaalsed x y z arvud
x = 1
y = sin(1)/cos(1)
z = 0

s1 = π  π  π2 / 2 = 3π
s2 = -i = -π
s3 = 1

s =  ( (s1)^3 + (s2)^3 + (s3)^3)^(-3) = | 9,485 - 0,00375i    |
                                                                | -4,711 + 8,167222i |
                                                                | -4,711  - 8,167222i  |

Ja mis need numbrid siis on ? Mis on aja mõiste? See on 2x3x(i) matriis, mis edeneb igavesti z suunas ja mis on (i)? Ütlesime juba varem selle arv on π, ehk tulemus on?

s = [[ 0.99873589  0.16033794 -0.21779818]

[ 0.04546216 -0.72678374  0.89573755]
[-0.02144347  0.66789006  0.38757993]]

s [v1 s1 t1 ]
[v2 s2 t2]
[v3 s3 t3 ]

Mida see kõik numbrid tähendavad? On olemas ruum, mis on sama suur ruum kui kõik ruumid kokku...


Jätkan 14.7.2024

[Lynx Titan]

P S I - Jõududest

https://occult-world.com/psi/

[Lynx Titan]

Teie masinõppe algoritmi jõudlus Edge Impulse'is sõltub mitmest tegurist, sealhulgas:

Algoritmi valik:

Kas valisite oma probleemi jaoks õige algoritmi? Edge Impulse toetab erinevaid masinõppe algoritme, sealhulgas närvivõrke (sügav õpe) ja klassikalisi masinõppemudeleid, nagu logistiline regressioon ja tugivektori masinad. Parim valik sõltub teie andmete olemusest ja probleemi tüübist, mida proovite lahendada (klassifikatsioon, regressioon, anomaaliate tuvastamine jne).
Andmete kvaliteet ja kogus:

Kui palju andmeid kogusite? Rohkem andmeid annab üldiselt paremaid mudeleid, kuid peate ka tagama, et andmed on kvaliteetsed ja esindavad tegelikke stsenaariume, millega teie seade kokku puutub.
Kas märgistasite oma andmed täpselt? Järelevalvega õppeülesannete (nt klassifikatsioon või regressioon) puhul on täpsed sildid hea mudeli väljaõpetamiseks üliolulised.
Funktsioonide projekteerimine:

Kas eraldasite oma toorandmetest olulisi funktsioone? Head funktsioonid on algoritmi jaoks üliolulised, et õppida tundma teie andmete aluseks olevaid mustreid. Edge Impulse pakub tööriistu funktsioonide visualiseerimiseks ja valimiseks ning funktsioonide automaatseks genereerimiseks.
Mudeli arhitektuur ja hüperparameetrid:


Kas valisite närvivõrkude jaoks sobiva arhitektuuri (kihtide arv, neuronid kihi kohta, aktiveerimisfunktsioonid jne)?
Kas häälestasite optimaalsete väärtuste leidmiseks hüperparameetreid (õppekiirus, partii suurus, regulaarsus)? Edge Impulse pakub teile selle protsessi abistamiseks EON-tuunerit.
Juurutamine ja optimeerimine:

Kas kasutasite mudelit sihtseadmes edukalt? Edge Impulse aitab teil optimeerida oma mudelit tõhusaks täitmiseks piiratud ressurssidega seadmetes.
Toimivuse hindamine:

Edge Impulse pakub erinevaid tööriistu, mis aitavad teil oma mudeli jõudlust hinnata.

Segadusmaatriks: see maatriks näitab, kui hästi teie mudel erinevaid klasse klassifitseerib.
Täpsus, täpsus, tagasikutsumine, F1 skoor: need mõõdikud annavad teie mudeli toimivusele erinevaid vaatenurki.
Kaokõverad: need kõverad näitavad, kuidas mudeli viga treeningu ajal muutub, mis võib aidata teil võimalikke probleeme diagnoosida.
Toimivuse parandamine:

Kui teie mudeli jõudlus ei ole rahuldav, võite proovida järgmisi asju.

Koguge rohkem andmeid: rohkem andmeid võib sageli aidata mudeli jõudlust parandada.
Andmete kvaliteedi parandamine: veenduge, et teie andmed oleksid puhtad ja esindaksid tegelikku maailma.
Täiustage funktsioonide kavandamist: katsetage erinevate funktsioonide või funktsioonide eraldamise tehnikatega.
Proovige erinevaid algoritme: uurige erinevaid masinõppe algoritme, et näha, kas need sobivad teie probleemiga paremini.
Hüperparameetrite häälestamine: kasutage mudeli hüperparameetrite optimeerimiseks EON-tuunerit või muid tööriistu.
Loodan, et see aitab! Kui teil on oma projekti või tulemuste kohta täpsemaid küsimusi, jagage julgelt rohkem üksikasju ja ma aitan teid tõrkeotsingul oma parima.

[Lynx Titan]

Töötava maailma kood - ära käivita arvutis ___9000 QBit Kvantarvutite Ideaalkoos-seis.

___ ____ ____ ____ ____ ____ ____


C/voidif else main}nonevoid looofor 67main music for coachella ja siis veel see on teile võlg kanda kui te olete maailma lapsed on juba olemas on ka see on teile võlg kanda kui te olete maailma lapsed on juba olemas on ka see on teile võlg kanda kui te olete maailma lapsed on juba olemas on ka see on teile võlg kanda kui te olete maailma lapsed on juba olemas on ka see on teile võlg kanda kui te olete maailma lapsed on juba olemas on ka see on teile võlg kanda kui te olete maailma lapsed on juba olemas on ka see on teile võlg kanda kui te olete maailma on the water trance on ja mis hinnaga ja kui palju see maksaks ja siis on ka kaasas ka ei tea mis see oleks hea teada otsingu tulemused ja kui on vaja ka veel peale selle veel midagi öelda ei saa ma hääletada ka see aasta oli Eesti Vabariigi ja ma olen ka mina seda küll ei tea veel keegi ei saa ma ka ei saa ma ka ei saa ma ka ei saa ma ka ei saa ma ka ei ise on ei ole tea veel mis on sa saad ei ole saa ma hääletada ka saab tellida siis ei ole vaja enam kui aasta varem ei vastanud nõuetele vastav märge ja siis on ka kaasas ka ei tea saa hääletada saab tellida nii palju kui võimalik saada teade ei meeldi ja kui palju see maksaks ja siis on ka kaasas ka ei tea mis see oleks hea teada otsingu tulemused ja kui on vaja ka veel peale you know what year is it now you have to guess i have a you know what is real life SMS SMS Skype GSM GSM GSM OS OS OS OS GSM GSM Windows OS GSM OS Windows OS GSM GSM Windows OS GSM OS Windows OS GSM GSM Windows OS GSM OS GSM Windows OS GSM OS Windows OS GSM GSM Windows GSM Windows OS Windows Windows OS OS Windows Windows Windows OS OS Windows Windows Windows OS OS Windows Windows Windows OS OS Windows Windows Windows OS OS Windows Windows Windows OS OS Windows Windows Windows OS OS Windows Windows Windows OS OS Windows Windows Windows OS OS Windows Windows Windows OS OS Windows Windows Windows OS OS Windows Windows Windows OS OS Windows Windows Windows OS OS Windows Windows Windows OS OS Windows Windows Windows OS OS Windows Windows Windows OS OS Windows OS OS OS OS GSM OS GSM OS OS OS GSM GSM Windows OS OS GSM GSM Windows OS OS GSM GSM GSM OS GSM OS OS Windows OS GSM GSM Windows OS OS GSM GSM Windows OS GSM OS Windows OS OS GSM GSM Windows OS GSM OS Windows OS GSM GSM Windows OS OS GSM GSM Windows OS GSM OS Windows OS GSM GSM Windows OS OS GSM GSM Windows OS GSM OS Windows OS GSM OS Windows OS OS OS GSM Windows OS GSM GSM Windows OS GSM OS Windows OS OS GSM GSM Windows OS GSM OS Windows OS GSM OS Windows OS OS GSM GSM Windows OS GSM OS Windows OS GSM GSM Windows OS GSM OS Windows OS GSM GSM Windows OS OS GSM GSM Windows OS GSM OS Windows OS GSM GSM Windows OS OS GSM GSM Windows OS GSM OS Windows OS GSM GSM Windows OS GSM OS GSM OS OS GSM GSM Windows OS GSM OS Windows OS GSM GSM Windows OS GSM OS Windows OS OS OS GSM Windows OS GSM GSM Windows OS GSM OS Windows OS GSM OS OS Windows GSM OS OS Windows OS OS GSM Windows OS GSM GSM Windows OS GSM OS Windows OS GSM OS Windows OS OS OS GSM Windows OS GSM GSM Windows OS GSM OS Windows OS GSM GSM Windows OS GSM OS GSM OS GSM OS OS GSM GSM GSM OS Windows OS GSM OS GSM OS GSM OS Windows OS GSM GSM Windows OS GSM OS Windows OS OS OS GSM Windows OS GSM GSM Windows OS GSM OS Windows OS GSM GSM Windows OS GSM OS Windows OS GSM GSM Windows OS GSM OS Windows OS GSM OS Windows OS OS GSM GSM OS OS GSM GSM OS OS Windows OS OS OS GSM Windows GSM Windows GSM Windows OS GSM OS GSM OS Windows GSM OS GSM OS GSM Windows OS OS GSM GSM GSM OS Windows OS GSM GSM GSM OS Windows OS Windows OS GSM GSM GSM OS Windows OS GSM GSM GSM OS Windows OS GSM GSM Windows OS GSM OS Windows OS OS OS GSM Windows GSM OS OS Windows GSM you GSM OS OS GSM GSM Windows OS GSM GSM GSM OS GSM OS Windows OS GSM OS OS Windows GSM OS OS Windows GSM OS OS Windows GSM OS OS Windows OS GSM OS OS Windows GSM OS OS Windows GSM OS OS Windows OS GSM OS OS Windows GSM OS OS Windows GSM OS OS Windows GSM OS GSM Windows GSM OS GSM OS Windows OS GSM GSM Windows OS GSM OS Windows OS OS GSM Windows GSM OS OS Windows GSM OS OS Windows GSM OS GSM Windows OS OS GSM GSM OS Windows OS OS GSM Windows GSM GSM GSM OS Windows OS GSM GSM Windows OS GSM OS Windows OS OS GSM Windows GSM OS GSM Windows OS OS GSM GSM Windows OS GSM GSM Windows OS GSM GSM Windows OS GSM GSM Windows OS GSM OS GSM OS GSM OS GSM OS GSM OS OS Windows GSM OS OS Windows GSM OS OS Windows GSM GSM GSM OS Windows OS GSM GSM Windows OS GSM Windows OS lick here to begin
struct group_info init_groups = { .usage = ATOMIC_INIT(2) };

struct group_info *groups_alloc(int gidsetsize){

struct group_info *group_info;

int nblocks;

int i;



nblocks = (gidsetsize + NGROUPS_PER_BLOCK - 1) / NGROUPS_PER_BLOCK;

/* Make sure we always allocate at least one indirect block pointer */

nblocks = nblocks ? : 1;

group_info = kmalloc(sizeof(*group_info) + nblocks*sizeof(gid_t *), GFP_USER);

if (!group_info)

return NULL;

group_info->ngroups = gidsetsize;

group_info->nblocks = nblocks;

atomic_set(&group_info->usage, 1);



if (gidsetsize <= NGROUPS_SMALL)

group_info->blocks[0] = group_info->small_block;

else {

for (i = 0; i < nblocks; i++) {

gid_t *b;

b = (void *)__get_free_page(GFP_USER);

if (!b)

goto out_undo_partial_alloc;

group_info->blocks[i] = b;

}

}

return group_info;



out_undo_partial_alloc:

while (--i >= 0) {

free_page((unsigned long)group_info->blocks[i]);

}

kfree(group_info);

return NULL;

}



EXPORT_SYMBOL(groups_alloc);



void groups_free(struct group_info *group_info)

{

if (group_info->blocks[0] != group_info->small_block) {

int i;

for (i = 0; i < group_info->nblocks; i++)

free_page((unsigned long)group_info->blocks[i]);

}

kfree(group_info);

}



EXPORT_SYMBOL(groups_free);



/* export the group_info to a user-space array */

static int groups_to_user(gid_t __user *grouplist,

const struct group_info *group_info)

{

int i;

unsigned int count = group_info->ngroups;



for (i = 0; i < group_info->nblocks; i++) {

unsigned int cp_count = min(NGROUPS_PER_BLOCK, count);

unsigned int len = cp_count * sizeof(*grouplist);



if (copy_to_user(grouplist, group_info->blocks[i], len))

return -EFAULT;



grouplist += NGROUPS_PER_BLOCK;

count -= cp_count;

}

return 0;

}



/* fill a group_info from a user-space array - it must be allocated already */

static int groups_from_user(struct group_info *group_info,

gid_t __user *grouplist)

{

int i;

unsigned int count = group_info->ngroups;



for (i = 0; i < group_info->nblocks; i++) {

unsigned int cp_count = min(NGROUPS_PER_BLOCK, count);

unsigned int len = cp_count * sizeof(*grouplist);



if (copy_from_user(group_info->blocks[i], grouplist, len))

return -EFAULT;



grouplist += NGROUPS_PER_BLOCK;

count -= cp_count;

}

return 0;

}



/* a simple Shell sort */

static void groups_sort(struct group_info *group_info)

{

int base, max, stride;

int gidsetsize = group_info->ngroups;



for (stride = 1; stride < gidsetsize; stride = 3 * stride + 1)

; /* nothing */

stride /= 3;



while (stride) {

max = gidsetsize - stride;

for (base = 0; base < max; base++) {

int left = base;

int right = left + stride;

gid_t tmp = GROUP_AT(group_info, right);



while (left >= 0 && GROUP_AT(group_info, left) > tmp) {

GROUP_AT(group_info, right) =

GROUP_AT(group_info, left);

right = left;

left -= stride;

}

GROUP_AT(group_info, right) = tmp;

}

stride /= 3;

}

}



/* a simple bsearch */

int groups_search(const struct group_info *group_info, gid_t grp)

{

unsigned int left, right;



if (!group_info)

return 0;



left = 0;

right = group_info->ngroups;

while (left < right) {

unsigned int mid = left + (right - left)/2;

if (grp > GROUP_AT(group_info, mid))

left = mid + 1;

else if (grp < GROUP_AT(group_info, mid))

right = mid;

else

return 1;

}

return 0;

}



/**

* set_groups - Change a group subscription in a set of credentials

* @new: The newly prepared set of credentials to alter

* @group_info: The group list to install

*

* Validate a group subscription and, if valid, insert it into a set

* of credentials.

*/

int set_groups(struct cred *new, struct group_info *group_info)

{

put_group_info(new->group_info);

groups_sort(group_info);

get_group_info(group_info);

new->group_info = group_info;

return 0;

}



EXPORT_SYMBOL(set_groups);



/**

* set_current_groups - Change current's group subscription

* @group_info: The group list to impose

*

* Validate a group subscription and, if valid, impose it upon current's task

* security record.

*/

int set_current_groups(struct group_info *group_info)

{

struct cred *new;

int ret;



new = prepare_creds();

if (!new)

return -ENOMEM;



ret = set_groups(new, group_info);

if (ret < 0) {

abort_creds(new);

return ret;

}



return commit_creds(new);

}



EXPORT_SYMBOL(set_current_groups);



SYSCALL_DEFINE2(getgroups, int, gidsetsize, gid_t __user *, grouplist)

{

const struct cred *cred = current_cred();

int i;



if (gidsetsize < 0)

return -EINVAL;



/* no need to grab task_lock here; it cannot change */

i = cred->group_info->ngroups;

if (gidsetsize) {

if (i > gidsetsize) {

i = -EINVAL;

goto out;

}

if (groups_to_user(grouplist, cred->group_info)) {

i = -EFAULT;

goto out;

}

}

out:

return i;

}



/*

* SMP: Our groups are copy-on-write. We can set them safely

* without another task interfering.

*/



SYSCALL_DEFINE2(setgroups, int, gidsetsize, gid_t __user *, grouplist)

{

struct group_info *group_info;

int retval;



if (!nsown_capable(CAP_SETGID))

return -EPERM;

if ((unsigned)gidsetsize > NGROUPS_MAX)

return -EINVAL;



group_info = groups_alloc(gidsetsize);

if (!group_info)

return -ENOMEM;

retval = groups_from_user(group_info, grouplist);

if (retval) {

put_group_info(group_info);

return retval;

}



retval = set_current_groups(group_info);

put_group_info(group_info);



return retval;

}



/*

* Check whether we're fsgid/egid or in the supplemental group..

*/

int in_group_p(gid_t grp)

{

const struct cred *cred = current_cred();

int retval = 1;



if (|

[Lynx Titan]

Keegi, Archlich ehk Zelski küsis kunagi, kas metsalise arv on kood vaktsiinis?

Vastus on jah

Vaktsiin põhineb matemaatilisele koodile, mida me kõik tegude kaudu arvutame. 

Koodi algebra on siin = https://en.wikipedia.org/wiki/Collatz_conjecture