C++

içinde std :: complex ile karmaşık sonsuzluk oluşturma Inf + Inf * j'ye eşit bir karmaşık sonsuzluk oluşturmaya çalışıyorum, burada j, karmaşık değişkendir. Bunu yaparken: C++

#include <complex> 
#include <limits> 
using std; 

... 

complex<double> attempt1 = 
    complex<double>(numeric_limits<double>::infinity(), 
        numeric_limits<double>::infinity());

karmaşık sayı (NaN + Inf * j) döndürür.

complex<double> attempt2 = 
    complex<double>(numeric_limits<double>::infinity());

Ancak

karmaşık sayı (Inf + 0 * j) döndürür. Ayrıca

complex<double> attempt_at_imag_inf = 
    complex<double>(any_value_here, numeric_limits<double>::infinity());

karmaşık sayı (NaN + Inf * j) döndürür.

Burada neler olduğunu kimse bilen var mı? Her ne zaman hayali bölüm için istila etmeye çalışırsam, o zaman NaN gerçek kısımda yazılır.

Yukarıdakiler, sadece NaN ve Sonsuzluğu destekleyen türleri kapsar. G ++ v4.6.1 kullanıyorum. Numeric_limits üstbilgisine baktım ve yukarıdakilerin hepsinin olması gerektiğine dair bir işaret yok.

Yukarıdaki içeriği bağlam içine koymak için, yukarıda sayısal olarak karmaşık için karmaşık bir uzmanlık uzmanı olarak yapıyorum. Bu problemi düşündüğünüz için çok teşekkürler. ORİJİNAL POST

İÇİN

REVİZYON

Sorunu göstermek için komple ama kısa programı sunan ediyorum. Ayrıca, programın sonuçları üretmek için nasıl derlenmesi gerektiği hakkında daha fazla bilgi de ekledim. STD = C++ 0 x seçenek olmadan

my_complex_inf = (nan,inf) 
attempt2 = (inf,0) 
attempt_at_imag_inf = (nan,inf)

: g yukarıdaki derleme

#include <iostream> 
#include <complex> 
#include <limits> 

using namespace std; 

int main(int argc, char* argv[]) 
{ 

    complex<double> my_complex_inf = 
     complex<double>(numeric_limits<double>::infinity(), 
         numeric_limits<double>::infinity()); 

    cout << "my_complex_inf = " << my_complex_inf << endl; 

    complex<double> attempt2 = 
     complex<double>(numeric_limits<double>::infinity()); 

    cout << "attempt2 = " << attempt2 << endl; 

    double any_value_here = 0; 

    complex<double> attempt_at_imag_inf = 
     complex<double>(0, numeric_limits<double>::infinity()); 

    cout << "attempt_at_imag_inf = " << attempt_at_imag_inf << endl; 

    return 0; 

}

-std = C++ 0 x ile Ubuntu ++ sürüm 4.6.1 çözgünlük tetkiki sonuçlar şu şekildedir:

my_complex_inf = (inf,inf) 
attempt2 = (inf,0) 
attempt_at_imag_inf = (0,inf)

Yani gerçekten soru GNU g ++ V4.6.1 C++ 0x belirtildiğinde NE YAPAR CEVAP VEREN EDER NEDEN nedir? ORİJİNAL POST

İÇİN

REVISION 2 Sadece Octave (MATLAB benzeri Rakamsal paketi) aşağıdaki çalıştı:

a = inf + j * inf

Cevap ise

a = NaN + Infi

Bu tam benim C++ 11 kodunda gördükleri şeydir (C++ 0x). Octave'in ne ile derlendiğini bilmiyorum (C++ ve FORTRAN'ın bir kombinasyonu olduğuna inanıyorum) ama bu paket elde ettiğim sonucu döndürürse, bunun iyi bilinen bir davranış olduğunu varsayardım. Bununla birlikte, C++ 11 taslak standardına baktım ve bu davranıştan hiç bir şey bulamıyorum.

REVİZYON 3 ORİJİNAL SONRASI

aşağıdaki satırı ekleyerek İÇİN

my_complex_inf.real(my_complex_inf.imag());

sadece my_complex_inf inşaatı C++ 11 için derlenmiş "doğru" cevabı (inf, inf) dönmek sonra. Ne yazık ki, bu şimdi 2 aşamalı bir süreç ve ben bir constexpr işlevinde bu tür karmaşık sonsuzluk oluşturamıyorum.

kaynak

2012-05-14 Ender St. John-Olcayto

Düzgün çalışır [on g ++ 4.3.4] (http://ideone.com/xfXDo), [g ++ 4.5.1] (http://ideone.com/FpmZK), 4.6.3 ve 4.7.0. Lütfen kısa, eksiksiz, örnek bir program sağlayın. Bkz. Http://sscce.org/. –

Karmaşık uçak için 4 olası sonsuzluk istediğinizden emin misiniz? Sadece bir tane isteyeceğinizi düşünürdüm (Riemann alanında olduğu gibi). –

Eh, 1/std :: complex (0) 'ı deneyebilirsiniz, çünkü istediğiniz tek önemli şey Riemann küresini temsil etmeye çalışıyorsanız 1/infty == 0'dır. –

Komplekse dönüştürülen bir skaler Inf inf + 0 j'dir. Ths yukarıda doğru. Kompleks düzlemde bir skaler Inf ofseti, bir dönüşü ima eder ve hesaplanamaz, bu nedenle Nan doğrudur. Yine sorun nedir?

"Ejderha var."

kaynak

2012-05-16 20:31:14 starbolin

a = 1 olsun 1 + 0 * j. Pi/4'ün bir rotasyonu 1 x exp (j * pi/4) yani sqrt (2) + j * sqrt (2) 'dir. Eğer bir inf varsa, o zaman b = inf * exp (j * pi/4). Bu, hem gerçek hem de karmaşık parçaların inf çoğalmasını içerdiğinden, sonuç aynı zamanda inf (gerçek ve karmaşık parçalar için) olmalıdır. Bu yüzden, eğer nan de bir dönme bilgisinin ortaya çıkması gerektiğini düşünmüyorum. nasıl uygulanır. –

C++ 11'in (ve C11'in) karmaşık sayıları belirtme ve kafanızın karışmasına neden oluyorsunuz. Temel olarak, spesifikasyon tarafından belirlenen modelde, sadece bir sonsuzluk (temsil (inf, 0)) vardır ve Nan'deki karmaşık sonuçların hayali kısmına bir 'sonsuzluk' koymaya çalışır, çünkü Bu modelde bir anlam ifade etmiyor.

kaynak

2012-05-16 23:18:17

ana hat olarak (gcc-4.8) ı ile elde -std = C++ 0x beklenen (bir -std) cevap: -std-C++ 11

my_complex_inf = (inf,inf) 
attempt2 = (inf,0) 
attempt_at_imag_inf = (0,inf)

gcc-4.6.3

my_complex_inf = (-nan,inf) 
attempt2 = (inf,0) 
attempt_at_imag_inf = (-nan,inf)

Ben kurucular sadece karşılık gelen argümanlar göre gerçek ve hayali türlerini ayarlamak gerektiğini düşünüyorum: beklenmeyen cevap verir. nan olmamalıdır.

kaynak

2012-05-17 02:29:32 emsr

cevap

İlgili konular