Initial Commit
This commit is contained in:
Jordan Sherer
Binary file not shown.
|
After Width: | Height: | Size: 4.9 KiB |
@@ -0,0 +1,618 @@
|
||||
// -*- Mode: C++ -*-
|
||||
#ifndef MAINWINDOW_H
|
||||
#define MAINWINDOW_H
|
||||
#ifdef QT5
|
||||
#include <QtWidgets>
|
||||
#else
|
||||
#include <QtGui>
|
||||
#endif
|
||||
#include <QThread>
|
||||
#include <QTimer>
|
||||
#include <QDateTime>
|
||||
#include <QList>
|
||||
#include <QAudioDeviceInfo>
|
||||
#include <QScopedPointer>
|
||||
#include <QDir>
|
||||
#include <QProgressDialog>
|
||||
#include <QAbstractSocket>
|
||||
#include <QHostAddress>
|
||||
#include <QPointer>
|
||||
#include <QSet>
|
||||
#include <QVector>
|
||||
#include <QFuture>
|
||||
#include <QFutureWatcher>
|
||||
|
||||
#include "AudioDevice.hpp"
|
||||
#include "commons.h"
|
||||
#include "Radio.hpp"
|
||||
#include "Modes.hpp"
|
||||
#include "FrequencyList.hpp"
|
||||
#include "Configuration.hpp"
|
||||
#include "WSPRBandHopping.hpp"
|
||||
#include "Transceiver.hpp"
|
||||
#include "DisplayManual.hpp"
|
||||
#include "psk_reporter.h"
|
||||
#include "logbook/logbook.h"
|
||||
#include "decodedtext.h"
|
||||
#include "commons.h"
|
||||
#include "astro.h"
|
||||
#include "MessageBox.hpp"
|
||||
#include "NetworkAccessManager.hpp"
|
||||
|
||||
#define NUM_JT4_SYMBOLS 206 //(72+31)*2, embedded sync
|
||||
#define NUM_JT65_SYMBOLS 126 //63 data + 63 sync
|
||||
#define NUM_JT9_SYMBOLS 85 //69 data + 16 sync
|
||||
#define NUM_WSPR_SYMBOLS 162 //(50+31)*2, embedded sync
|
||||
#define NUM_WSPR_LF_SYMBOLS 412 //300 data + 109 sync + 3 ramp
|
||||
#define NUM_ISCAT_SYMBOLS 1291 //30*11025/256
|
||||
#define NUM_MSK144_SYMBOLS 144 //s8 + d48 + s8 + d80
|
||||
#define NUM_QRA64_SYMBOLS 84 //63 data + 21 sync
|
||||
#define NUM_FT8_SYMBOLS 79
|
||||
#define NUM_CW_SYMBOLS 250
|
||||
#define TX_SAMPLE_RATE 48000
|
||||
#define N_WIDGETS 24
|
||||
|
||||
extern int volatile itone[NUM_ISCAT_SYMBOLS]; //Audio tones for all Tx symbols
|
||||
extern int volatile icw[NUM_CW_SYMBOLS]; //Dits for CW ID
|
||||
|
||||
//--------------------------------------------------------------- MainWindow
|
||||
namespace Ui {
|
||||
class MainWindow;
|
||||
}
|
||||
|
||||
class QSettings;
|
||||
class QLineEdit;
|
||||
class QFont;
|
||||
class QHostInfo;
|
||||
class EchoGraph;
|
||||
class FastGraph;
|
||||
class WideGraph;
|
||||
class LogQSO;
|
||||
class Transceiver;
|
||||
class MessageAveraging;
|
||||
class MessageClient;
|
||||
class QTime;
|
||||
class WSPRBandHopping;
|
||||
class HelpTextWindow;
|
||||
class WSPRNet;
|
||||
class SoundOutput;
|
||||
class Modulator;
|
||||
class SoundInput;
|
||||
class Detector;
|
||||
class SampleDownloader;
|
||||
class MultiSettings;
|
||||
class PhaseEqualizationDialog;
|
||||
|
||||
class MainWindow : public QMainWindow
|
||||
{
|
||||
Q_OBJECT;
|
||||
|
||||
public:
|
||||
using Frequency = Radio::Frequency;
|
||||
using FrequencyDelta = Radio::FrequencyDelta;
|
||||
using Mode = Modes::Mode;
|
||||
|
||||
explicit MainWindow(QDir const& temp_directory, bool multiple, MultiSettings *,
|
||||
QSharedMemory *shdmem, unsigned downSampleFactor,
|
||||
QSplashScreen *,
|
||||
QWidget *parent = nullptr);
|
||||
~MainWindow();
|
||||
|
||||
public slots:
|
||||
void showSoundInError(const QString& errorMsg);
|
||||
void showSoundOutError(const QString& errorMsg);
|
||||
void showStatusMessage(const QString& statusMsg);
|
||||
void dataSink(qint64 frames);
|
||||
void fastSink(qint64 frames);
|
||||
void diskDat();
|
||||
void freezeDecode(int n);
|
||||
void guiUpdate();
|
||||
void doubleClickOnCall(bool shift, bool ctrl);
|
||||
void doubleClickOnCall2(bool shift, bool ctrl);
|
||||
void readFromStdout();
|
||||
void p1ReadFromStdout();
|
||||
void setXIT(int n, Frequency base = 0u);
|
||||
void setFreq4(int rxFreq, int txFreq);
|
||||
void msgAvgDecode2();
|
||||
void fastPick(int x0, int x1, int y);
|
||||
|
||||
protected:
|
||||
void keyPressEvent (QKeyEvent *) override;
|
||||
void closeEvent(QCloseEvent *) override;
|
||||
void childEvent(QChildEvent *) override;
|
||||
bool eventFilter(QObject *, QEvent *) override;
|
||||
|
||||
private slots:
|
||||
void on_tx1_editingFinished();
|
||||
void on_tx2_editingFinished();
|
||||
void on_tx3_editingFinished();
|
||||
void on_tx4_editingFinished();
|
||||
void on_tx5_currentTextChanged (QString const&);
|
||||
void on_tx6_editingFinished();
|
||||
void on_actionSettings_triggered();
|
||||
void on_monitorButton_clicked (bool);
|
||||
void on_actionAbout_triggered();
|
||||
void on_autoButton_clicked (bool);
|
||||
void on_stopTxButton_clicked();
|
||||
void on_stopButton_clicked();
|
||||
void on_actionRelease_Notes_triggered ();
|
||||
void on_actionOnline_User_Guide_triggered();
|
||||
void on_actionLocal_User_Guide_triggered();
|
||||
void on_actionWide_Waterfall_triggered();
|
||||
void on_actionOpen_triggered();
|
||||
void on_actionOpen_next_in_directory_triggered();
|
||||
void on_actionDecode_remaining_files_in_directory_triggered();
|
||||
void on_actionDelete_all_wav_files_in_SaveDir_triggered();
|
||||
void on_actionOpen_log_directory_triggered ();
|
||||
void on_actionNone_triggered();
|
||||
void on_actionSave_all_triggered();
|
||||
void on_actionKeyboard_shortcuts_triggered();
|
||||
void on_actionSpecial_mouse_commands_triggered();
|
||||
void on_DecodeButton_clicked (bool);
|
||||
void decode();
|
||||
void decodeBusy(bool b);
|
||||
void on_EraseButton_clicked();
|
||||
void on_txb1_clicked();
|
||||
void on_txFirstCheckBox_stateChanged(int arg1);
|
||||
void set_dateTimeQSO(int m_ntx);
|
||||
void set_ntx(int n);
|
||||
void on_txrb1_toggled(bool status);
|
||||
void on_txrb2_toggled(bool status);
|
||||
void on_txrb3_toggled(bool status);
|
||||
void on_txb2_clicked();
|
||||
void on_txb3_clicked();
|
||||
void on_txb4_clicked();
|
||||
void on_txb5_clicked();
|
||||
void on_txb6_clicked();
|
||||
void on_lookupButton_clicked();
|
||||
void on_addButton_clicked();
|
||||
void on_dxCallEntry_textChanged (QString const&);
|
||||
void on_dxGridEntry_textChanged (QString const&);
|
||||
void on_dxCallEntry_returnPressed ();
|
||||
void on_genStdMsgsPushButton_clicked();
|
||||
void on_logQSOButton_clicked();
|
||||
void on_actionJT9_triggered();
|
||||
void on_actionJT65_triggered();
|
||||
void on_actionJT9_JT65_triggered();
|
||||
void on_actionJT4_triggered();
|
||||
void on_actionFT8_triggered();
|
||||
void on_TxFreqSpinBox_valueChanged(int arg1);
|
||||
void on_actionSave_decoded_triggered();
|
||||
void on_actionQuickDecode_toggled (bool);
|
||||
void on_actionMediumDecode_toggled (bool);
|
||||
void on_actionDeepestDecode_toggled (bool);
|
||||
void on_inGain_valueChanged(int n);
|
||||
void bumpFqso(int n);
|
||||
void on_actionErase_ALL_TXT_triggered();
|
||||
void on_actionErase_wsjtx_log_adi_triggered();
|
||||
void startTx2();
|
||||
void startP1();
|
||||
void stopTx();
|
||||
void stopTx2();
|
||||
void on_pbCallCQ_clicked();
|
||||
void on_pbAnswerCaller_clicked();
|
||||
void on_pbSendRRR_clicked();
|
||||
void on_pbAnswerCQ_clicked();
|
||||
void on_pbSendReport_clicked();
|
||||
void on_pbSend73_clicked();
|
||||
void on_rbGenMsg_clicked(bool checked);
|
||||
void on_rbFreeText_clicked(bool checked);
|
||||
void on_freeTextMsg_currentTextChanged (QString const&);
|
||||
void on_rptSpinBox_valueChanged(int n);
|
||||
void killFile();
|
||||
void on_tuneButton_clicked (bool);
|
||||
void on_pbR2T_clicked();
|
||||
void on_pbT2R_clicked();
|
||||
void acceptQSO2(QDateTime const&, QString const& call, QString const& grid
|
||||
, Frequency dial_freq, QString const& mode
|
||||
, QString const& rpt_sent, QString const& rpt_received
|
||||
, QString const& tx_power, QString const& comments
|
||||
, QString const& name, QDateTime const&);
|
||||
void on_bandComboBox_currentIndexChanged (int index);
|
||||
void on_bandComboBox_activated (int index);
|
||||
void on_readFreq_clicked();
|
||||
void on_pbTxMode_clicked();
|
||||
void on_RxFreqSpinBox_valueChanged(int n);
|
||||
void on_cbTxLock_clicked(bool checked);
|
||||
void on_outAttenuation_valueChanged (int);
|
||||
void rigOpen ();
|
||||
void handle_transceiver_update (Transceiver::TransceiverState const&);
|
||||
void handle_transceiver_failure (QString const& reason);
|
||||
void on_actionAstronomical_data_toggled (bool);
|
||||
void on_actionShort_list_of_add_on_prefixes_and_suffixes_triggered();
|
||||
void band_changed (Frequency);
|
||||
void monitor (bool);
|
||||
void stop_tuning ();
|
||||
void stopTuneATU();
|
||||
void auto_tx_mode(bool);
|
||||
void on_actionMessage_averaging_triggered();
|
||||
void on_actionInclude_averaging_toggled (bool);
|
||||
void on_actionInclude_correlation_toggled (bool);
|
||||
void on_actionEnable_AP_DXcall_toggled (bool);
|
||||
void VHF_features_enabled(bool b);
|
||||
void on_sbSubmode_valueChanged(int n);
|
||||
void on_cbShMsgs_toggled(bool b);
|
||||
void on_cbSWL_toggled(bool b);
|
||||
void on_cbTx6_toggled(bool b);
|
||||
void networkError (QString const&);
|
||||
void on_ClrAvgButton_clicked();
|
||||
void on_actionWSPR_triggered();
|
||||
void on_actionWSPR_LF_triggered();
|
||||
void on_syncSpinBox_valueChanged(int n);
|
||||
void on_TxPowerComboBox_currentIndexChanged(const QString &arg1);
|
||||
void on_sbTxPercent_valueChanged(int n);
|
||||
void on_cbUploadWSPR_Spots_toggled(bool b);
|
||||
void WSPR_config(bool b);
|
||||
void uploadSpots();
|
||||
void TxAgain();
|
||||
void uploadResponse(QString response);
|
||||
void on_WSPRfreqSpinBox_valueChanged(int n);
|
||||
void on_pbTxNext_clicked(bool b);
|
||||
void on_actionEcho_Graph_triggered();
|
||||
void on_actionEcho_triggered();
|
||||
void on_actionISCAT_triggered();
|
||||
void on_actionFast_Graph_triggered();
|
||||
void on_actionHide_Controls_toggled (bool chaecked);
|
||||
void fast_decode_done();
|
||||
void on_actionMeasure_reference_spectrum_triggered();
|
||||
void on_actionErase_reference_spectrum_triggered();
|
||||
void on_actionMeasure_phase_response_triggered();
|
||||
void on_sbTR_valueChanged (int);
|
||||
void on_sbFtol_valueChanged (int);
|
||||
void on_cbFast9_clicked(bool b);
|
||||
void on_sbCQTxFreq_valueChanged(int n);
|
||||
void on_cbCQTx_toggled(bool b);
|
||||
void on_actionMSK144_triggered();
|
||||
void on_actionQRA64_triggered();
|
||||
void on_actionFreqCal_triggered();
|
||||
void splash_done ();
|
||||
|
||||
private:
|
||||
Q_SIGNAL void initializeAudioOutputStream (QAudioDeviceInfo,
|
||||
unsigned channels, unsigned msBuffered) const;
|
||||
Q_SIGNAL void stopAudioOutputStream () const;
|
||||
Q_SIGNAL void startAudioInputStream (QAudioDeviceInfo const&,
|
||||
int framesPerBuffer, AudioDevice * sink,
|
||||
unsigned downSampleFactor, AudioDevice::Channel) const;
|
||||
Q_SIGNAL void suspendAudioInputStream () const;
|
||||
Q_SIGNAL void resumeAudioInputStream () const;
|
||||
Q_SIGNAL void startDetector (AudioDevice::Channel) const;
|
||||
Q_SIGNAL void FFTSize (unsigned) const;
|
||||
Q_SIGNAL void detectorClose () const;
|
||||
Q_SIGNAL void finished () const;
|
||||
Q_SIGNAL void transmitFrequency (double) const;
|
||||
Q_SIGNAL void endTransmitMessage (bool quick = false) const;
|
||||
Q_SIGNAL void tune (bool = true) const;
|
||||
Q_SIGNAL void sendMessage (unsigned symbolsLength, double framesPerSymbol,
|
||||
double frequency, double toneSpacing,
|
||||
SoundOutput *, AudioDevice::Channel = AudioDevice::Mono,
|
||||
bool synchronize = true, bool fastMode = false, double dBSNR = 99.,
|
||||
int TRperiod=60) const;
|
||||
Q_SIGNAL void outAttenuationChanged (qreal) const;
|
||||
Q_SIGNAL void toggleShorthand () const;
|
||||
|
||||
private:
|
||||
void astroUpdate ();
|
||||
void writeAllTxt(QString message);
|
||||
void FT8_AutoSeq(QString message);
|
||||
|
||||
NetworkAccessManager m_network_manager;
|
||||
bool m_valid;
|
||||
QSplashScreen * m_splash;
|
||||
QDir m_dataDir;
|
||||
QString m_revision;
|
||||
bool m_multiple;
|
||||
MultiSettings * m_multi_settings;
|
||||
QPushButton * m_configurations_button;
|
||||
QSettings * m_settings;
|
||||
QScopedPointer<Ui::MainWindow> ui;
|
||||
|
||||
// other windows
|
||||
Configuration m_config;
|
||||
WSPRBandHopping m_WSPR_band_hopping;
|
||||
bool m_WSPR_tx_next;
|
||||
MessageBox m_rigErrorMessageBox;
|
||||
QScopedPointer<SampleDownloader> m_sampleDownloader;
|
||||
QScopedPointer<PhaseEqualizationDialog> m_phaseEqualizationDialog;
|
||||
|
||||
QScopedPointer<WideGraph> m_wideGraph;
|
||||
QScopedPointer<EchoGraph> m_echoGraph;
|
||||
QScopedPointer<FastGraph> m_fastGraph;
|
||||
QScopedPointer<LogQSO> m_logDlg;
|
||||
QScopedPointer<Astro> m_astroWidget;
|
||||
QScopedPointer<HelpTextWindow> m_shortcuts;
|
||||
QScopedPointer<HelpTextWindow> m_prefixes;
|
||||
QScopedPointer<HelpTextWindow> m_mouseCmnds;
|
||||
QScopedPointer<MessageAveraging> m_msgAvgWidget;
|
||||
|
||||
Transceiver::TransceiverState m_rigState;
|
||||
Frequency m_lastDialFreq;
|
||||
QString m_lastBand;
|
||||
Frequency m_dialFreqRxWSPR; // best guess at WSPR QRG
|
||||
|
||||
Detector * m_detector;
|
||||
unsigned m_FFTSize;
|
||||
SoundInput * m_soundInput;
|
||||
Modulator * m_modulator;
|
||||
SoundOutput * m_soundOutput;
|
||||
QThread m_audioThread;
|
||||
|
||||
qint64 m_msErase;
|
||||
qint64 m_secBandChanged;
|
||||
qint64 m_freqMoon;
|
||||
Frequency m_freqNominal;
|
||||
Frequency m_freqTxNominal;
|
||||
Astro::Correction m_astroCorrection;
|
||||
|
||||
double m_s6;
|
||||
double m_tRemaining;
|
||||
|
||||
float m_DTtol;
|
||||
float m_t0;
|
||||
float m_t1;
|
||||
float m_t0Pick;
|
||||
float m_t1Pick;
|
||||
float m_fCPUmskrtd;
|
||||
|
||||
qint32 m_waterfallAvg;
|
||||
qint32 m_ntx;
|
||||
bool m_gen_message_is_cq;
|
||||
qint32 m_timeout;
|
||||
qint32 m_XIT;
|
||||
qint32 m_setftx;
|
||||
qint32 m_ndepth;
|
||||
qint32 m_sec0;
|
||||
qint32 m_RxLog;
|
||||
qint32 m_nutc0;
|
||||
qint32 m_ntr;
|
||||
qint32 m_tx;
|
||||
qint32 m_hsym;
|
||||
qint32 m_TRperiod;
|
||||
qint32 m_nsps;
|
||||
qint32 m_hsymStop;
|
||||
qint32 m_inGain;
|
||||
qint32 m_ncw;
|
||||
qint32 m_secID;
|
||||
qint32 m_idleMinutes;
|
||||
qint32 m_nSubMode;
|
||||
qint32 m_nclearave;
|
||||
qint32 m_minSync;
|
||||
qint32 m_dBm;
|
||||
qint32 m_pctx;
|
||||
qint32 m_nseq;
|
||||
qint32 m_nWSPRdecodes;
|
||||
qint32 m_k0;
|
||||
qint32 m_kdone;
|
||||
qint32 m_nPick;
|
||||
FrequencyList::const_iterator m_frequency_list_fcal_iter;
|
||||
qint32 m_nTx73;
|
||||
qint32 m_UTCdisk;
|
||||
qint32 m_wait;
|
||||
|
||||
bool m_btxok; //True if OK to transmit
|
||||
bool m_diskData;
|
||||
bool m_loopall;
|
||||
bool m_decoderBusy;
|
||||
bool m_txFirst;
|
||||
bool m_auto;
|
||||
bool m_restart;
|
||||
bool m_startAnother;
|
||||
bool m_saveDecoded;
|
||||
bool m_saveAll;
|
||||
bool m_widebandDecode;
|
||||
bool m_call3Modified;
|
||||
bool m_dataAvailable;
|
||||
bool m_bDecoded;
|
||||
bool m_noSuffix;
|
||||
bool m_blankLine;
|
||||
bool m_decodedText2;
|
||||
bool m_freeText;
|
||||
bool m_sentFirst73;
|
||||
int m_currentMessageType;
|
||||
QString m_currentMessage;
|
||||
int m_lastMessageType;
|
||||
QString m_lastMessageSent;
|
||||
bool m_lockTxFreq;
|
||||
bool m_bShMsgs;
|
||||
bool m_bSWL;
|
||||
bool m_uploadSpots;
|
||||
bool m_uploading;
|
||||
bool m_txNext;
|
||||
bool m_grid6;
|
||||
bool m_tuneup;
|
||||
bool m_bTxTime;
|
||||
bool m_rxDone;
|
||||
bool m_bSimplex; // not using split even if it is available
|
||||
bool m_bEchoTxOK;
|
||||
bool m_bTransmittedEcho;
|
||||
bool m_bEchoTxed;
|
||||
bool m_bFastMode;
|
||||
bool m_bFast9;
|
||||
bool m_bFastDecodeCalled;
|
||||
bool m_bDoubleClickAfterCQnnn;
|
||||
bool m_bRefSpec;
|
||||
bool m_bClearRefSpec;
|
||||
bool m_bTrain;
|
||||
bool m_bUseRef;
|
||||
bool m_bFastDone;
|
||||
bool m_bAltV;
|
||||
bool m_bNoMoreFiles;
|
||||
bool m_bQRAsyncWarned;
|
||||
bool m_bDoubleClicked;
|
||||
|
||||
int m_ihsym;
|
||||
int m_nzap;
|
||||
int m_npts8;
|
||||
float m_px;
|
||||
float m_pxmax;
|
||||
float m_df3;
|
||||
int m_iptt0;
|
||||
bool m_btxok0;
|
||||
int m_nsendingsh;
|
||||
double m_onAirFreq0;
|
||||
bool m_first_error;
|
||||
|
||||
char m_msg[100][80];
|
||||
|
||||
// labels in status bar
|
||||
QLabel tx_status_label;
|
||||
QLabel config_label;
|
||||
QLabel mode_label;
|
||||
QLabel last_tx_label;
|
||||
QLabel auto_tx_label;
|
||||
QLabel band_hopping_label;
|
||||
QProgressBar progressBar;
|
||||
QLabel watchdog_label;
|
||||
|
||||
QFuture<void> m_wav_future;
|
||||
QFutureWatcher<void> m_wav_future_watcher;
|
||||
QFutureWatcher<void> watcher3;
|
||||
QFutureWatcher<QString> m_saveWAVWatcher;
|
||||
|
||||
QProcess proc_jt9;
|
||||
QProcess p1;
|
||||
QProcess p3;
|
||||
|
||||
WSPRNet *wsprNet;
|
||||
|
||||
QTimer m_guiTimer;
|
||||
QTimer ptt1Timer; //StartTx delay
|
||||
QTimer ptt0Timer; //StopTx delay
|
||||
QTimer logQSOTimer;
|
||||
QTimer killFileTimer;
|
||||
QTimer tuneButtonTimer;
|
||||
QTimer uploadTimer;
|
||||
QTimer tuneATU_Timer;
|
||||
QTimer TxAgainTimer;
|
||||
QTimer minuteTimer;
|
||||
QTimer splashTimer;
|
||||
QTimer p1Timer;
|
||||
|
||||
QString m_path;
|
||||
QString m_baseCall;
|
||||
QString m_hisCall;
|
||||
QString m_hisGrid;
|
||||
QString m_appDir;
|
||||
QString m_palette;
|
||||
QString m_dateTime;
|
||||
QString m_mode;
|
||||
QString m_modeTx;
|
||||
QString m_fnameWE; // save path without extension
|
||||
QString m_rpt;
|
||||
QString m_rptSent;
|
||||
QString m_rptRcvd;
|
||||
QString m_qsoStart;
|
||||
QString m_qsoStop;
|
||||
QString m_cmnd;
|
||||
QString m_cmndP1;
|
||||
QString m_msgSent0;
|
||||
QString m_fileToSave;
|
||||
QString m_calls;
|
||||
|
||||
QSet<QString> m_pfx;
|
||||
QSet<QString> m_sfx;
|
||||
|
||||
QDateTime m_dateTimeQSOOn;
|
||||
QDateTime m_dateTimeQSOOff;
|
||||
QDateTime m_dateTimeDefault;
|
||||
|
||||
QSharedMemory *mem_jt9;
|
||||
LogBook m_logBook;
|
||||
DecodedText m_QSOText;
|
||||
unsigned m_msAudioOutputBuffered;
|
||||
unsigned m_framesAudioInputBuffered;
|
||||
unsigned m_downSampleFactor;
|
||||
QThread::Priority m_audioThreadPriority;
|
||||
bool m_bandEdited;
|
||||
bool m_splitMode;
|
||||
bool m_monitoring;
|
||||
bool m_transmitting;
|
||||
bool m_tune;
|
||||
bool m_tx_watchdog; // true when watchdog triggered
|
||||
bool m_block_pwr_tooltip;
|
||||
bool m_PwrBandSetOK;
|
||||
bool m_bVHFwarned;
|
||||
Frequency m_lastMonitoredFrequency;
|
||||
double m_toneSpacing;
|
||||
int m_firstDecode;
|
||||
QProgressDialog m_optimizingProgress;
|
||||
QTimer m_heartbeat;
|
||||
MessageClient * m_messageClient;
|
||||
PSK_Reporter *psk_Reporter;
|
||||
DisplayManual m_manual;
|
||||
QHash<QString, QVariant> m_pwrBandTxMemory; // Remembers power level by band
|
||||
QHash<QString, QVariant> m_pwrBandTuneMemory; // Remembers power level by band for tuning
|
||||
QByteArray m_geometryNoControls;
|
||||
QVector<double> m_phaseEqCoefficients;
|
||||
|
||||
//---------------------------------------------------- private functions
|
||||
void readSettings();
|
||||
void setDecodedTextFont (QFont const&);
|
||||
void writeSettings();
|
||||
void createStatusBar();
|
||||
void updateStatusBar();
|
||||
void genStdMsgs(QString rpt);
|
||||
void genCQMsg();
|
||||
void clearDX ();
|
||||
void lookup();
|
||||
void ba2msg(QByteArray ba, char* message);
|
||||
void msgtype(QString t, QLineEdit* tx);
|
||||
void stub();
|
||||
void statusChanged();
|
||||
void fixStop();
|
||||
bool shortList(QString callsign);
|
||||
void transmit (double snr = 99.);
|
||||
void rigFailure (QString const& reason);
|
||||
void pskSetLocal ();
|
||||
void pskPost(DecodedText decodedtext);
|
||||
void displayDialFrequency ();
|
||||
void transmitDisplay (bool);
|
||||
void processMessage(QString const& messages, qint32 position, bool ctrl);
|
||||
void replyToCQ (QTime, qint32 snr, float delta_time, quint32 delta_frequency, QString const& mode, QString const& message_text);
|
||||
void replayDecodes ();
|
||||
void postDecode (bool is_new, QString const& message);
|
||||
void postWSPRDecode (bool is_new, QStringList message_parts);
|
||||
void enable_DXCC_entity (bool on);
|
||||
void switch_mode (Mode);
|
||||
void WSPR_scheduling ();
|
||||
void freqCalStep();
|
||||
void setRig (Frequency = 0); // zero frequency means no change
|
||||
void WSPR_history(Frequency dialFreq, int ndecodes);
|
||||
QString WSPR_hhmm(int n);
|
||||
void fast_config(bool b);
|
||||
void CQTxFreq();
|
||||
QString save_wave_file (QString const& name
|
||||
, short const * data
|
||||
, int seconds
|
||||
, QString const& my_callsign
|
||||
, QString const& my_grid
|
||||
, QString const& mode
|
||||
, qint32 sub_mode
|
||||
, Frequency frequency
|
||||
, QString const& his_call
|
||||
, QString const& his_grid) const;
|
||||
void read_wav_file (QString const& fname);
|
||||
void decodeDone ();
|
||||
void subProcessFailed (QProcess *, int exit_code, QProcess::ExitStatus);
|
||||
void subProcessError (QProcess *, QProcess::ProcessError);
|
||||
void statusUpdate () const;
|
||||
void update_watchdog_label ();
|
||||
void on_the_minute ();
|
||||
void add_child_to_event_filter (QObject *);
|
||||
void remove_child_from_event_filter (QObject *);
|
||||
void setup_status_bar (bool vhf);
|
||||
void tx_watchdog (bool triggered);
|
||||
int nWidgets(QString t);
|
||||
void displayWidgets(int n);
|
||||
void vhfWarning();
|
||||
QChar current_submode () const; // returns QChar {0} if sub mode is
|
||||
// not appropriate
|
||||
};
|
||||
|
||||
extern int killbyname(const char* progName);
|
||||
extern void getDev(int* numDevices,char hostAPI_DeviceName[][50],
|
||||
int minChan[], int maxChan[],
|
||||
int minSpeed[], int maxSpeed[]);
|
||||
extern int next_tx_state(int pctx);
|
||||
|
||||
#endif // MAINWINDOW_H
|
||||
@@ -0,0 +1,51 @@
|
||||
// Copyright David Abrahams 2002.
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
#ifndef INSTANCE_DWA200295_HPP
|
||||
# define INSTANCE_DWA200295_HPP
|
||||
|
||||
# include <boost/python/detail/prefix.hpp>
|
||||
# include <boost/type_traits/alignment_traits.hpp>
|
||||
# include <cstddef>
|
||||
|
||||
namespace boost { namespace python
|
||||
{
|
||||
struct BOOST_PYTHON_DECL_FORWARD instance_holder;
|
||||
}} // namespace boost::python
|
||||
|
||||
namespace boost { namespace python { namespace objects {
|
||||
|
||||
// Each extension instance will be one of these
|
||||
template <class Data = char>
|
||||
struct instance
|
||||
{
|
||||
PyObject_VAR_HEAD
|
||||
PyObject* dict;
|
||||
PyObject* weakrefs;
|
||||
instance_holder* objects;
|
||||
|
||||
typedef typename type_with_alignment<
|
||||
::boost::alignment_of<Data>::value
|
||||
>::type align_t;
|
||||
|
||||
union
|
||||
{
|
||||
align_t align;
|
||||
char bytes[sizeof(Data)];
|
||||
} storage;
|
||||
};
|
||||
|
||||
template <class Data>
|
||||
struct additional_instance_size
|
||||
{
|
||||
typedef instance<Data> instance_data;
|
||||
typedef instance<char> instance_char;
|
||||
BOOST_STATIC_CONSTANT(
|
||||
std::size_t, value = sizeof(instance_data)
|
||||
- BOOST_PYTHON_OFFSETOF(instance_char,storage));
|
||||
};
|
||||
|
||||
}}} // namespace boost::python::object
|
||||
|
||||
#endif // INSTANCE_DWA200295_HPP
|
||||
@@ -0,0 +1,156 @@
|
||||
// Copyright David Abrahams 2002.
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
#ifndef OBJECT_MANAGER_DWA2002614_HPP
|
||||
# define OBJECT_MANAGER_DWA2002614_HPP
|
||||
|
||||
# include <boost/python/handle.hpp>
|
||||
# include <boost/python/cast.hpp>
|
||||
# include <boost/python/converter/pyobject_traits.hpp>
|
||||
# include <boost/type_traits/object_traits.hpp>
|
||||
# include <boost/mpl/if.hpp>
|
||||
# include <boost/python/detail/indirect_traits.hpp>
|
||||
# include <boost/mpl/bool.hpp>
|
||||
|
||||
// Facilities for dealing with types which always manage Python
|
||||
// objects. Some examples are object, list, str, et. al. Different
|
||||
// to_python/from_python conversion rules apply here because in
|
||||
// contrast to other types which are typically embedded inside a
|
||||
// Python object, these are wrapped around a Python object. For most
|
||||
// object managers T, a C++ non-const T reference argument does not
|
||||
// imply the existence of a T lvalue embedded in the corresponding
|
||||
// Python argument, since mutating member functions on T actually only
|
||||
// modify the held Python object.
|
||||
//
|
||||
// handle<T> is an object manager, though strictly speaking it should
|
||||
// not be. In other words, even though mutating member functions of
|
||||
// hanlde<T> actually modify the handle<T> and not the T object,
|
||||
// handle<T>& arguments of wrapped functions will bind to "rvalues"
|
||||
// wrapping the actual Python argument, just as with other object
|
||||
// manager classes. Making an exception for handle<T> is simply not
|
||||
// worth the trouble.
|
||||
//
|
||||
// borrowed<T> cv* is an object manager so that we can use the general
|
||||
// to_python mechanisms to convert raw Python object pointers to
|
||||
// python, without the usual semantic problems of using raw pointers.
|
||||
|
||||
|
||||
// Object Manager Concept requirements:
|
||||
//
|
||||
// T is an Object Manager
|
||||
// p is a PyObject*
|
||||
// x is a T
|
||||
//
|
||||
// * object_manager_traits<T>::is_specialized == true
|
||||
//
|
||||
// * T(detail::borrowed_reference(p))
|
||||
// Manages p without checking its type
|
||||
//
|
||||
// * get_managed_object(x, boost::python::tag)
|
||||
// Convertible to PyObject*
|
||||
//
|
||||
// Additional requirements if T can be converted from_python:
|
||||
//
|
||||
// * T(object_manager_traits<T>::adopt(p))
|
||||
// steals a reference to p, or throws a TypeError exception if
|
||||
// p doesn't have an appropriate type. May assume p is non-null
|
||||
//
|
||||
// * X::check(p)
|
||||
// convertible to bool. True iff T(X::construct(p)) will not
|
||||
// throw.
|
||||
|
||||
// Forward declarations
|
||||
//
|
||||
namespace boost { namespace python
|
||||
{
|
||||
namespace api
|
||||
{
|
||||
class object;
|
||||
}
|
||||
}}
|
||||
|
||||
namespace boost { namespace python { namespace converter {
|
||||
|
||||
|
||||
// Specializations for handle<T>
|
||||
template <class T>
|
||||
struct handle_object_manager_traits
|
||||
: pyobject_traits<typename T::element_type>
|
||||
{
|
||||
private:
|
||||
typedef pyobject_traits<typename T::element_type> base;
|
||||
|
||||
public:
|
||||
BOOST_STATIC_CONSTANT(bool, is_specialized = true);
|
||||
|
||||
// Initialize with a null_ok pointer for efficiency, bypassing the
|
||||
// null check since the source is always non-null.
|
||||
static null_ok<typename T::element_type>* adopt(PyObject* p)
|
||||
{
|
||||
return python::allow_null(base::checked_downcast(p));
|
||||
}
|
||||
};
|
||||
|
||||
template <class T>
|
||||
struct default_object_manager_traits
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(
|
||||
bool, is_specialized = python::detail::is_borrowed_ptr<T>::value
|
||||
);
|
||||
};
|
||||
|
||||
template <class T>
|
||||
struct object_manager_traits
|
||||
: mpl::if_c<
|
||||
is_handle<T>::value
|
||||
, handle_object_manager_traits<T>
|
||||
, default_object_manager_traits<T>
|
||||
>::type
|
||||
{
|
||||
};
|
||||
|
||||
//
|
||||
// Traits for detecting whether a type is an object manager or a
|
||||
// (cv-qualified) reference to an object manager.
|
||||
//
|
||||
|
||||
template <class T>
|
||||
struct is_object_manager
|
||||
: mpl::bool_<object_manager_traits<T>::is_specialized>
|
||||
{
|
||||
};
|
||||
|
||||
template <class T>
|
||||
struct is_reference_to_object_manager
|
||||
: mpl::false_
|
||||
{
|
||||
};
|
||||
|
||||
template <class T>
|
||||
struct is_reference_to_object_manager<T&>
|
||||
: is_object_manager<T>
|
||||
{
|
||||
};
|
||||
|
||||
template <class T>
|
||||
struct is_reference_to_object_manager<T const&>
|
||||
: is_object_manager<T>
|
||||
{
|
||||
};
|
||||
|
||||
template <class T>
|
||||
struct is_reference_to_object_manager<T volatile&>
|
||||
: is_object_manager<T>
|
||||
{
|
||||
};
|
||||
|
||||
template <class T>
|
||||
struct is_reference_to_object_manager<T const volatile&>
|
||||
: is_object_manager<T>
|
||||
{
|
||||
};
|
||||
|
||||
}}} // namespace boost::python::converter
|
||||
|
||||
#endif // OBJECT_MANAGER_DWA2002614_HPP
|
||||
@@ -0,0 +1,17 @@
|
||||
/*
|
||||
* Copyright (c) 2014 Glen Fernandes
|
||||
*
|
||||
* Distributed under the Boost Software License, Version 1.0. (See
|
||||
* accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
|
||||
#ifndef BOOST_CHECKED_DELETE_HPP
|
||||
#define BOOST_CHECKED_DELETE_HPP
|
||||
|
||||
// The header file at this path is deprecated;
|
||||
// use boost/core/checked_delete.hpp instead.
|
||||
|
||||
#include <boost/core/checked_delete.hpp>
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,51 @@
|
||||
// Copyright Neil Groves 2009. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
//
|
||||
// For more information, see http://www.boost.org/libs/range/
|
||||
//
|
||||
#ifndef BOOST_RANGE_ALGORITHM_UNIQUE_COPY_HPP_INCLUDED
|
||||
#define BOOST_RANGE_ALGORITHM_UNIQUE_COPY_HPP_INCLUDED
|
||||
|
||||
#include <boost/concept_check.hpp>
|
||||
#include <boost/range/begin.hpp>
|
||||
#include <boost/range/end.hpp>
|
||||
#include <boost/range/concepts.hpp>
|
||||
#include <algorithm>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
namespace range
|
||||
{
|
||||
|
||||
/// \brief template function unique_copy
|
||||
///
|
||||
/// range-based version of the unique_copy std algorithm
|
||||
///
|
||||
/// \pre SinglePassRange is a model of the SinglePassRangeConcept
|
||||
/// \pre OutputIterator is a model of the OutputIteratorConcept
|
||||
/// \pre BinaryPredicate is a model of the BinaryPredicateConcept
|
||||
template< class SinglePassRange, class OutputIterator >
|
||||
inline OutputIterator
|
||||
unique_copy( const SinglePassRange& rng, OutputIterator out_it )
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
|
||||
return std::unique_copy(boost::begin(rng), boost::end(rng), out_it);
|
||||
}
|
||||
/// \overload
|
||||
template< class SinglePassRange, class OutputIterator, class BinaryPredicate >
|
||||
inline OutputIterator
|
||||
unique_copy( const SinglePassRange& rng, OutputIterator out_it,
|
||||
BinaryPredicate pred )
|
||||
{
|
||||
BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
|
||||
return std::unique_copy(boost::begin(rng), boost::end(rng), out_it, pred);
|
||||
}
|
||||
|
||||
} // namespace range
|
||||
using range::unique_copy;
|
||||
} // namespace boost
|
||||
|
||||
#endif // include guard
|
||||
@@ -0,0 +1,27 @@
|
||||
subroutine wspr_fsk8_downsample(iwave,c)
|
||||
|
||||
! Input: i*2 data in iwave() at sample rate 12000 Hz
|
||||
! Output: Complex data in c(), sampled at 12000/24=500 Hz
|
||||
|
||||
include 'wspr_fsk8_params.f90'
|
||||
integer*2 iwave(NMAX)
|
||||
complex c(0:NMAXD-1)
|
||||
complex c1(0:NMAXD-1)
|
||||
complex cx(0:NMAX/2)
|
||||
real x(NMAX)
|
||||
equivalence (x,cx)
|
||||
|
||||
df=12000.0/NMAX
|
||||
x=iwave
|
||||
call four2a(x,NMAX,1,-1,0) !r2c FFT to freq domain
|
||||
i0=nint(1500.0/df)
|
||||
c1(0)=cx(i0)
|
||||
do i=1,NMAXD/2
|
||||
c1(i)=cx(i0+i)
|
||||
c1(NMAXD-i)=cx(i0-i)
|
||||
enddo
|
||||
c=c1/NMAXD
|
||||
call four2a(c,NMAXD,1,1,1) !c2c FFT back to time domain
|
||||
|
||||
return
|
||||
end subroutine wspr_fsk8_downsample
|
||||
@@ -0,0 +1,67 @@
|
||||
#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
|
||||
|
||||
#include <boost/proto/detail/preprocessed/make_expr_funop.hpp>
|
||||
|
||||
#elif !defined(BOOST_PP_IS_ITERATING)
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 2, line: 0, output: "preprocessed/make_expr_funop.hpp")
|
||||
#endif
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file make_expr_funop.hpp
|
||||
/// Contains definition of make_expr\<\>::operator() member functions.
|
||||
//
|
||||
// Copyright 2008 Eric Niebler. Distributed under the Boost
|
||||
// Software License, Version 1.0. (See accompanying file
|
||||
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 1)
|
||||
#endif
|
||||
|
||||
#define BOOST_PP_ITERATION_PARAMS_1 \
|
||||
(3, (2, BOOST_PROTO_MAX_ARITY, <boost/proto/detail/make_expr_funop.hpp>))
|
||||
#include BOOST_PP_ITERATE()
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(output: null)
|
||||
#endif
|
||||
|
||||
#else // BOOST_PP_IS_ITERATING
|
||||
|
||||
#define N BOOST_PP_ITERATION()
|
||||
|
||||
template<typename This BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
|
||||
struct result<This(BOOST_PP_ENUM_PARAMS(N, A))>
|
||||
{
|
||||
typedef
|
||||
typename result_of::make_expr<
|
||||
Tag
|
||||
, Domain
|
||||
BOOST_PP_ENUM_TRAILING_PARAMS(N, A)
|
||||
>::type
|
||||
type;
|
||||
};
|
||||
|
||||
/// \overload
|
||||
///
|
||||
template<BOOST_PP_ENUM_PARAMS(N, typename A)>
|
||||
BOOST_FORCEINLINE
|
||||
typename result_of::make_expr<
|
||||
Tag
|
||||
, Domain
|
||||
BOOST_PP_ENUM_TRAILING_PARAMS(N, const A)
|
||||
>::type const
|
||||
operator ()(BOOST_PP_ENUM_BINARY_PARAMS(N, const A, &a)) const
|
||||
{
|
||||
return proto::detail::make_expr_<
|
||||
Tag
|
||||
, Domain
|
||||
BOOST_PP_ENUM_TRAILING_PARAMS(N, const A)
|
||||
>()(BOOST_PP_ENUM_PARAMS(N, a));
|
||||
}
|
||||
|
||||
#undef N
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,118 @@
|
||||
#ifndef BOOST_SERIALIZATION_TRACKING_HPP
|
||||
#define BOOST_SERIALIZATION_TRACKING_HPP
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
#if defined(_MSC_VER)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
|
||||
// tracking.hpp:
|
||||
|
||||
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See http://www.boost.org for updates, documentation, and revision history.
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/static_assert.hpp>
|
||||
#include <boost/mpl/eval_if.hpp>
|
||||
#include <boost/mpl/identity.hpp>
|
||||
#include <boost/mpl/int.hpp>
|
||||
#include <boost/mpl/equal_to.hpp>
|
||||
#include <boost/mpl/greater.hpp>
|
||||
#include <boost/mpl/integral_c_tag.hpp>
|
||||
|
||||
#include <boost/type_traits/is_base_and_derived.hpp>
|
||||
#include <boost/type_traits/is_pointer.hpp>
|
||||
#include <boost/serialization/level.hpp>
|
||||
#include <boost/serialization/tracking_enum.hpp>
|
||||
#include <boost/serialization/type_info_implementation.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace serialization {
|
||||
|
||||
struct basic_traits;
|
||||
|
||||
// default tracking level
|
||||
template<class T>
|
||||
struct tracking_level_impl {
|
||||
template<class U>
|
||||
struct traits_class_tracking {
|
||||
typedef typename U::tracking type;
|
||||
};
|
||||
typedef mpl::integral_c_tag tag;
|
||||
// note: at least one compiler complained w/o the full qualification
|
||||
// on basic traits below
|
||||
typedef
|
||||
typename mpl::eval_if<
|
||||
is_base_and_derived<boost::serialization::basic_traits, T>,
|
||||
traits_class_tracking< T >,
|
||||
//else
|
||||
typename mpl::eval_if<
|
||||
is_pointer< T >,
|
||||
// pointers are not tracked by default
|
||||
mpl::int_<track_never>,
|
||||
//else
|
||||
typename mpl::eval_if<
|
||||
// for primitives
|
||||
typename mpl::equal_to<
|
||||
implementation_level< T >,
|
||||
mpl::int_<primitive_type>
|
||||
>,
|
||||
// is never
|
||||
mpl::int_<track_never>,
|
||||
// otherwise its selective
|
||||
mpl::int_<track_selectively>
|
||||
> > >::type type;
|
||||
BOOST_STATIC_CONSTANT(int, value = type::value);
|
||||
};
|
||||
|
||||
template<class T>
|
||||
struct tracking_level :
|
||||
public tracking_level_impl<const T>
|
||||
{
|
||||
};
|
||||
|
||||
template<class T, enum tracking_type L>
|
||||
inline bool operator>=(tracking_level< T > t, enum tracking_type l)
|
||||
{
|
||||
return t.value >= (int)l;
|
||||
}
|
||||
|
||||
} // namespace serialization
|
||||
} // namespace boost
|
||||
|
||||
|
||||
// The STATIC_ASSERT is prevents one from setting tracking for a primitive type.
|
||||
// This almost HAS to be an error. Doing this will effect serialization of all
|
||||
// char's in your program which is almost certainly what you don't want to do.
|
||||
// If you want to track all instances of a given primitive type, You'll have to
|
||||
// wrap it in your own type so its not a primitive anymore. Then it will compile
|
||||
// without problem.
|
||||
#define BOOST_CLASS_TRACKING(T, E) \
|
||||
namespace boost { \
|
||||
namespace serialization { \
|
||||
template<> \
|
||||
struct tracking_level< T > \
|
||||
{ \
|
||||
typedef mpl::integral_c_tag tag; \
|
||||
typedef mpl::int_< E> type; \
|
||||
BOOST_STATIC_CONSTANT( \
|
||||
int, \
|
||||
value = tracking_level::type::value \
|
||||
); \
|
||||
/* tracking for a class */ \
|
||||
BOOST_STATIC_ASSERT(( \
|
||||
mpl::greater< \
|
||||
/* that is a prmitive */ \
|
||||
implementation_level< T >, \
|
||||
mpl::int_<primitive_type> \
|
||||
>::value \
|
||||
)); \
|
||||
}; \
|
||||
}}
|
||||
|
||||
#endif // BOOST_SERIALIZATION_TRACKING_HPP
|
||||
@@ -0,0 +1,41 @@
|
||||
// Boost.Units - A C++ library for zero-overhead dimensional analysis and
|
||||
// unit/quantity manipulation and conversion
|
||||
//
|
||||
// Copyright (C) 2003-2008 Matthias Christian Schabel
|
||||
// Copyright (C) 2007-2008 Steven Watanabe
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef BOOST_UNITS_REDUCE_UNIT_HPP_INCLUDED
|
||||
#define BOOST_UNITS_REDUCE_UNIT_HPP_INCLUDED
|
||||
|
||||
/// \file
|
||||
/// \brief Returns a unique type for every unit.
|
||||
|
||||
namespace boost {
|
||||
namespace units {
|
||||
|
||||
#ifdef BOOST_UNITS_DOXYGEN
|
||||
|
||||
/// Returns a unique type for every unit.
|
||||
template<class Unit>
|
||||
struct reduce_unit {
|
||||
typedef detail::unspecified type;
|
||||
};
|
||||
|
||||
#else
|
||||
|
||||
// default implementation: return Unit unchanged.
|
||||
template<class Unit>
|
||||
struct reduce_unit {
|
||||
typedef Unit type;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,352 @@
|
||||
// filesystem path_traits.hpp --------------------------------------------------------//
|
||||
|
||||
// Copyright Beman Dawes 2009
|
||||
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// See http://www.boost.org/LICENSE_1_0.txt
|
||||
|
||||
// Library home page: http://www.boost.org/libs/filesystem
|
||||
|
||||
#ifndef BOOST_FILESYSTEM_PATH_TRAITS_HPP
|
||||
#define BOOST_FILESYSTEM_PATH_TRAITS_HPP
|
||||
|
||||
#include <boost/config.hpp>
|
||||
|
||||
# if defined( BOOST_NO_STD_WSTRING )
|
||||
# error Configuration not supported: Boost.Filesystem V3 and later requires std::wstring support
|
||||
# endif
|
||||
|
||||
#include <boost/filesystem/config.hpp>
|
||||
#include <boost/utility/enable_if.hpp>
|
||||
#include <boost/type_traits/is_array.hpp>
|
||||
#include <boost/type_traits/decay.hpp>
|
||||
#include <boost/system/error_code.hpp>
|
||||
#include <cwchar> // for mbstate_t
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <list>
|
||||
#include <iterator>
|
||||
#include <locale>
|
||||
#include <boost/assert.hpp>
|
||||
// #include <iostream> //**** comment me out ****
|
||||
|
||||
#include <boost/config/abi_prefix.hpp> // must be the last #include
|
||||
|
||||
namespace boost { namespace filesystem {
|
||||
|
||||
BOOST_FILESYSTEM_DECL const system::error_category& codecvt_error_category();
|
||||
// uses std::codecvt_base::result used for error codes:
|
||||
//
|
||||
// ok: Conversion successful.
|
||||
// partial: Not all source characters converted; one or more additional source
|
||||
// characters are needed to produce the final target character, or the
|
||||
// size of the target intermediate buffer was too small to hold the result.
|
||||
// error: A character in the source could not be converted to the target encoding.
|
||||
// noconv: The source and target characters have the same type and encoding, so no
|
||||
// conversion was necessary.
|
||||
|
||||
class directory_entry;
|
||||
|
||||
namespace path_traits {
|
||||
|
||||
typedef std::codecvt<wchar_t, char, std::mbstate_t> codecvt_type;
|
||||
|
||||
// is_pathable type trait; allows disabling over-agressive class path member templates
|
||||
|
||||
template <class T>
|
||||
struct is_pathable { static const bool value = false; };
|
||||
|
||||
template<> struct is_pathable<char*> { static const bool value = true; };
|
||||
template<> struct is_pathable<const char*> { static const bool value = true; };
|
||||
template<> struct is_pathable<wchar_t*> { static const bool value = true; };
|
||||
template<> struct is_pathable<const wchar_t*> { static const bool value = true; };
|
||||
template<> struct is_pathable<std::string> { static const bool value = true; };
|
||||
template<> struct is_pathable<std::wstring> { static const bool value = true; };
|
||||
template<> struct is_pathable<std::vector<char> > { static const bool value = true; };
|
||||
template<> struct is_pathable<std::vector<wchar_t> > { static const bool value = true; };
|
||||
template<> struct is_pathable<std::list<char> > { static const bool value = true; };
|
||||
template<> struct is_pathable<std::list<wchar_t> > { static const bool value = true; };
|
||||
template<> struct is_pathable<directory_entry> { static const bool value = true; };
|
||||
|
||||
// Pathable empty
|
||||
|
||||
template <class Container> inline
|
||||
// disable_if aids broken compilers (IBM, old GCC, etc.) and is harmless for
|
||||
// conforming compilers. Replace by plain "bool" at some future date (2012?)
|
||||
typename boost::disable_if<boost::is_array<Container>, bool>::type
|
||||
empty(const Container & c)
|
||||
{ return c.begin() == c.end(); }
|
||||
|
||||
template <class T> inline
|
||||
bool empty(T * const & c_str)
|
||||
{
|
||||
BOOST_ASSERT(c_str);
|
||||
return !*c_str;
|
||||
}
|
||||
|
||||
template <typename T, size_t N> inline
|
||||
bool empty(T (&x)[N])
|
||||
{ return !x[0]; }
|
||||
|
||||
// value types differ ---------------------------------------------------------------//
|
||||
//
|
||||
// A from_end argument of 0 is less efficient than a known end, so use only if needed
|
||||
|
||||
// with codecvt
|
||||
|
||||
BOOST_FILESYSTEM_DECL
|
||||
void convert(const char* from,
|
||||
const char* from_end, // 0 for null terminated MBCS
|
||||
std::wstring & to,
|
||||
const codecvt_type& cvt);
|
||||
|
||||
BOOST_FILESYSTEM_DECL
|
||||
void convert(const wchar_t* from,
|
||||
const wchar_t* from_end, // 0 for null terminated MBCS
|
||||
std::string & to,
|
||||
const codecvt_type& cvt);
|
||||
|
||||
inline
|
||||
void convert(const char* from,
|
||||
std::wstring & to,
|
||||
const codecvt_type& cvt)
|
||||
{
|
||||
BOOST_ASSERT(from);
|
||||
convert(from, 0, to, cvt);
|
||||
}
|
||||
|
||||
inline
|
||||
void convert(const wchar_t* from,
|
||||
std::string & to,
|
||||
const codecvt_type& cvt)
|
||||
{
|
||||
BOOST_ASSERT(from);
|
||||
convert(from, 0, to, cvt);
|
||||
}
|
||||
|
||||
// without codecvt
|
||||
|
||||
inline
|
||||
void convert(const char* from,
|
||||
const char* from_end, // 0 for null terminated MBCS
|
||||
std::wstring & to);
|
||||
|
||||
inline
|
||||
void convert(const wchar_t* from,
|
||||
const wchar_t* from_end, // 0 for null terminated MBCS
|
||||
std::string & to);
|
||||
|
||||
inline
|
||||
void convert(const char* from,
|
||||
std::wstring & to);
|
||||
|
||||
inline
|
||||
void convert(const wchar_t* from,
|
||||
std::string & to);
|
||||
|
||||
// value types same -----------------------------------------------------------------//
|
||||
|
||||
// char with codecvt
|
||||
|
||||
inline
|
||||
void convert(const char* from, const char* from_end, std::string & to,
|
||||
const codecvt_type&)
|
||||
{
|
||||
BOOST_ASSERT(from);
|
||||
BOOST_ASSERT(from_end);
|
||||
to.append(from, from_end);
|
||||
}
|
||||
|
||||
inline
|
||||
void convert(const char* from,
|
||||
std::string & to,
|
||||
const codecvt_type&)
|
||||
{
|
||||
BOOST_ASSERT(from);
|
||||
to += from;
|
||||
}
|
||||
|
||||
// wchar_t with codecvt
|
||||
|
||||
inline
|
||||
void convert(const wchar_t* from, const wchar_t* from_end, std::wstring & to,
|
||||
const codecvt_type&)
|
||||
{
|
||||
BOOST_ASSERT(from);
|
||||
BOOST_ASSERT(from_end);
|
||||
to.append(from, from_end);
|
||||
}
|
||||
|
||||
inline
|
||||
void convert(const wchar_t* from,
|
||||
std::wstring & to,
|
||||
const codecvt_type&)
|
||||
{
|
||||
BOOST_ASSERT(from);
|
||||
to += from;
|
||||
}
|
||||
|
||||
// char without codecvt
|
||||
|
||||
inline
|
||||
void convert(const char* from, const char* from_end, std::string & to)
|
||||
{
|
||||
BOOST_ASSERT(from);
|
||||
BOOST_ASSERT(from_end);
|
||||
to.append(from, from_end);
|
||||
}
|
||||
|
||||
inline
|
||||
void convert(const char* from, std::string & to)
|
||||
{
|
||||
BOOST_ASSERT(from);
|
||||
to += from;
|
||||
}
|
||||
|
||||
// wchar_t without codecvt
|
||||
|
||||
inline
|
||||
void convert(const wchar_t* from, const wchar_t* from_end, std::wstring & to)
|
||||
{
|
||||
BOOST_ASSERT(from);
|
||||
BOOST_ASSERT(from_end);
|
||||
to.append(from, from_end);
|
||||
}
|
||||
|
||||
inline
|
||||
void convert(const wchar_t* from, std::wstring & to)
|
||||
{
|
||||
BOOST_ASSERT(from);
|
||||
to += from;
|
||||
}
|
||||
|
||||
// Source dispatch -----------------------------------------------------------------//
|
||||
|
||||
// contiguous containers with codecvt
|
||||
template <class U> inline
|
||||
void dispatch(const std::string& c, U& to, const codecvt_type& cvt)
|
||||
{
|
||||
if (c.size())
|
||||
convert(&*c.begin(), &*c.begin() + c.size(), to, cvt);
|
||||
}
|
||||
template <class U> inline
|
||||
void dispatch(const std::wstring& c, U& to, const codecvt_type& cvt)
|
||||
{
|
||||
if (c.size())
|
||||
convert(&*c.begin(), &*c.begin() + c.size(), to, cvt);
|
||||
}
|
||||
template <class U> inline
|
||||
void dispatch(const std::vector<char>& c, U& to, const codecvt_type& cvt)
|
||||
{
|
||||
if (c.size())
|
||||
convert(&*c.begin(), &*c.begin() + c.size(), to, cvt);
|
||||
}
|
||||
template <class U> inline
|
||||
void dispatch(const std::vector<wchar_t>& c, U& to, const codecvt_type& cvt)
|
||||
{
|
||||
if (c.size())
|
||||
convert(&*c.begin(), &*c.begin() + c.size(), to, cvt);
|
||||
}
|
||||
|
||||
// contiguous containers without codecvt
|
||||
template <class U> inline
|
||||
void dispatch(const std::string& c, U& to)
|
||||
{
|
||||
if (c.size())
|
||||
convert(&*c.begin(), &*c.begin() + c.size(), to);
|
||||
}
|
||||
template <class U> inline
|
||||
void dispatch(const std::wstring& c, U& to)
|
||||
{
|
||||
if (c.size())
|
||||
convert(&*c.begin(), &*c.begin() + c.size(), to);
|
||||
}
|
||||
template <class U> inline
|
||||
void dispatch(const std::vector<char>& c, U& to)
|
||||
{
|
||||
if (c.size())
|
||||
convert(&*c.begin(), &*c.begin() + c.size(), to);
|
||||
}
|
||||
template <class U> inline
|
||||
void dispatch(const std::vector<wchar_t>& c, U& to)
|
||||
{
|
||||
if (c.size())
|
||||
convert(&*c.begin(), &*c.begin() + c.size(), to);
|
||||
}
|
||||
|
||||
// non-contiguous containers with codecvt
|
||||
template <class Container, class U> inline
|
||||
// disable_if aids broken compilers (IBM, old GCC, etc.) and is harmless for
|
||||
// conforming compilers. Replace by plain "void" at some future date (2012?)
|
||||
typename boost::disable_if<boost::is_array<Container>, void>::type
|
||||
dispatch(const Container & c, U& to, const codecvt_type& cvt)
|
||||
{
|
||||
if (c.size())
|
||||
{
|
||||
std::basic_string<typename Container::value_type> s(c.begin(), c.end());
|
||||
convert(s.c_str(), s.c_str()+s.size(), to, cvt);
|
||||
}
|
||||
}
|
||||
|
||||
// c_str
|
||||
template <class T, class U> inline
|
||||
void dispatch(T * const & c_str, U& to, const codecvt_type& cvt)
|
||||
{
|
||||
// std::cout << "dispatch() const T *\n";
|
||||
BOOST_ASSERT(c_str);
|
||||
convert(c_str, to, cvt);
|
||||
}
|
||||
|
||||
// Note: there is no dispatch on C-style arrays because the array may
|
||||
// contain a string smaller than the array size.
|
||||
|
||||
BOOST_FILESYSTEM_DECL
|
||||
void dispatch(const directory_entry & de,
|
||||
# ifdef BOOST_WINDOWS_API
|
||||
std::wstring & to,
|
||||
# else
|
||||
std::string & to,
|
||||
# endif
|
||||
const codecvt_type&);
|
||||
|
||||
// non-contiguous containers without codecvt
|
||||
template <class Container, class U> inline
|
||||
// disable_if aids broken compilers (IBM, old GCC, etc.) and is harmless for
|
||||
// conforming compilers. Replace by plain "void" at some future date (2012?)
|
||||
typename boost::disable_if<boost::is_array<Container>, void>::type
|
||||
dispatch(const Container & c, U& to)
|
||||
{
|
||||
if (c.size())
|
||||
{
|
||||
std::basic_string<typename Container::value_type> seq(c.begin(), c.end());
|
||||
convert(seq.c_str(), seq.c_str()+seq.size(), to);
|
||||
}
|
||||
}
|
||||
|
||||
// c_str
|
||||
template <class T, class U> inline
|
||||
void dispatch(T * const & c_str, U& to)
|
||||
{
|
||||
// std::cout << "dispatch() const T *\n";
|
||||
BOOST_ASSERT(c_str);
|
||||
convert(c_str, to);
|
||||
}
|
||||
|
||||
// Note: there is no dispatch on C-style arrays because the array may
|
||||
// contain a string smaller than the array size.
|
||||
|
||||
BOOST_FILESYSTEM_DECL
|
||||
void dispatch(const directory_entry & de,
|
||||
# ifdef BOOST_WINDOWS_API
|
||||
std::wstring & to
|
||||
# else
|
||||
std::string & to
|
||||
# endif
|
||||
);
|
||||
|
||||
|
||||
}}} // namespace boost::filesystem::path_traits
|
||||
|
||||
#include <boost/config/abi_suffix.hpp> // pops abi_prefix.hpp pragmas
|
||||
|
||||
#endif // BOOST_FILESYSTEM_PATH_TRAITS_HPP
|
||||
@@ -0,0 +1,29 @@
|
||||
// (c) Copyright Fernando Luis Cacciola Carballal 2000-2004
|
||||
// Use, modification, and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See library home page at http://www.boost.org/libs/numeric/conversion
|
||||
//
|
||||
// Contact the author at: fernando_cacciola@hotmail.com
|
||||
//
|
||||
#ifndef BOOST_NUMERIC_CONVERSION_SIGN_MIXTURE_ENUM_FLC_12NOV2002_HPP
|
||||
#define BOOST_NUMERIC_CONVERSION_SIGN_MIXTURE_ENUM_FLC_12NOV2002_HPP
|
||||
|
||||
namespace boost { namespace numeric
|
||||
{
|
||||
enum sign_mixture_enum
|
||||
{
|
||||
unsigned_to_unsigned
|
||||
,signed_to_signed
|
||||
,signed_to_unsigned
|
||||
,unsigned_to_signed
|
||||
} ;
|
||||
|
||||
} } // namespace boost::numeric
|
||||
|
||||
#endif
|
||||
//
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
@@ -0,0 +1,213 @@
|
||||
=== Frequency Calibration
|
||||
|
||||
Many _WSJT-X_ capabilities depend on signal-detection bandwidths no
|
||||
more than a few Hz. Frequency accuracy and stability are therefore
|
||||
unusually important. We provide tools to enable accurate frequency
|
||||
calibration of your radio, as well as precise frequency measurement of
|
||||
on-the-air signals. The calibration procedure works by automatically
|
||||
cycling your CAT-controlled radio through a series of preset
|
||||
frequencies of carrier-based signals at reliably known frequencies,
|
||||
measuring the error in dial frequency for each signal.
|
||||
|
||||
You will probably find it convenient to define and use a special
|
||||
<<CONFIG-MENU,Configuration>> dedicated to frequency calibration.
|
||||
Then complete the following steps, as appropriate for your system.
|
||||
|
||||
- Switch to FreqCal mode
|
||||
|
||||
- In the _Working Frequencies_ box on the *Settings -> Frequencies*
|
||||
tab, delete any default frequencies for *FreqCal* mode that are not
|
||||
relevant for your location. You may want to replace some of them with
|
||||
reliably known frequencies receivable at your location.
|
||||
|
||||
TIP: We find major-city AM broadcast stations generally serve well as
|
||||
frequency calibrators at the low frequency end of the spectrum. In
|
||||
North America we also use the standard time-and-frequency broadcasts
|
||||
of WWV at 2.500, 5.000, 10.000, 15.000, and 20.000 MHz, and CHU at
|
||||
3.330, 7.850, and 14.670 MHz. Similar shortwave signals are available
|
||||
in other parts of the world.
|
||||
|
||||
- In most cases you will want to start by deleting any existing file
|
||||
`fmt.all` in the directory where your log files are kept.
|
||||
|
||||
- Enter `0.0` for both *Slope* and *Intercept* under _Frequency
|
||||
Calibration_ on the *Settings -> Frequencies* tab.
|
||||
|
||||
- To cycle automatically through your chosen list of calibration
|
||||
frequencies, check *Execute frequency calibration cycle* on the
|
||||
*Tools* menu. _WSJT-X_ will spend 30 seconds at each frequency,
|
||||
writing its measurements to file `fmt.all` in the log directory.
|
||||
|
||||
- During the calibration procedure, the radio's USB dial frequency is
|
||||
offset 1500 Hz below each *FreqCal* entry in the default frequencies
|
||||
list. As shown in the screen shot below, detected signal carriers
|
||||
therefore appear at about 1500 Hz in the _WSJT-X_ waterfall.
|
||||
|
||||
image::FreqCal.png[align="left",alt="FreqCal"]
|
||||
|
||||
With modern synthesized radios, small measured offsets from 1500 Hz
|
||||
will exhibit a straight-line dependence on frequency. You can
|
||||
approximate the calibration of your radio by simply dividing the
|
||||
measured frequency offset (in Hz) at the highest reliable frequency by
|
||||
the nominal frequency itself (in MHz). For example, the 20 MHz
|
||||
measurement for WWV shown above produced a measured tone offset of
|
||||
24.6 Hz, displayed in the _WSJT-X_ decoded text window. The resulting
|
||||
calibration constant is 24.6/20=1.23 parts per million. This number
|
||||
may be entered as *Slope* on the *settings -> Frequencies* tab.
|
||||
|
||||
A more precise calibration can be effected by fitting the intercept
|
||||
and slope of a straight line to the whole sequence of calibration
|
||||
measurements, as shown for these measurements in the graph plotted
|
||||
below. Software tools for completing this task are included with the
|
||||
_WSJT-X_ installation, and detailed instructions for their use are
|
||||
available at https://physics.princeton.edu/pulsar/k1jt/FMT_User.pdf.
|
||||
|
||||
Using these tools and no specialized hardware beyond your
|
||||
CAT-interfaced radio, you can calibrate the radio to better than 1 Hz
|
||||
and compete very effectively in the ARRL's periodic Frequency
|
||||
Measuring Tests.
|
||||
|
||||
image::FreqCal_Graph.png[align="left",alt="FreqCal_Graph"]
|
||||
|
||||
After running *Execute frequency calibration cycle* at least once with
|
||||
good results, check and edit the file `fmt.all` in the log directory
|
||||
and delete any spurious or outlier measurements. The line-fitting
|
||||
procedure can then be carried out automatically by clicking *Solve for
|
||||
calibration parameters* on the *Tools* menu. The results will be
|
||||
displayed as in the following screen shot. Estimated uncertainties
|
||||
are included for slope and intercept; `N` is the number of averaged
|
||||
frequency measurements included in the fit, and `StdDev` is the root
|
||||
mean square deviation of averaged measurements from the fitted
|
||||
straight line.
|
||||
|
||||
image::FreqCal_Results.png[align="center",alt="FreqCal_Results"]
|
||||
|
||||
=== Reference Spectrum
|
||||
|
||||
_WSJT-X_ provides a tool that can be used to determine the detailed
|
||||
shape of your receiver's passband. Disconnect your antenna or tune to
|
||||
a quiet frequency with no signals. With WSJT-X running in one of the
|
||||
slow modes, select *Measure reference spectrum* from the *Tools* menu.
|
||||
Wait for about a minute and then hit the *Stop* button. A file named
|
||||
`refspec.dat` will appear in your log directory.
|
||||
|
||||
[ ... more to come ... ]
|
||||
|
||||
=== Phase Equalization
|
||||
|
||||
*Measure phase response* under the *Tools* menu is for advanced MSK144
|
||||
users. Phase equalization is used to compensate for group-delay
|
||||
variation across your receiver passband. Careful application of this
|
||||
facility can reduce intersymbol interference, resulting in improved
|
||||
decoding sensitivity. If you use a software-defined receiver with
|
||||
linear-phase filters there is no need to apply phase equalization.
|
||||
|
||||
After a frame of received data has been decoded, *Measure phase
|
||||
response* generates an undistorted audio waveform equal to the one
|
||||
generated by the transmitting station. Its Fourier transform is then
|
||||
used as a frequency-dependent phase reference to compare with the
|
||||
phase of the received frame's Fourier coefficients. Phase differences
|
||||
between the reference spectrum and received spectrum will include
|
||||
contributions from the originating station's transmit filter, the
|
||||
propagation channel, and filters in the receiver. If the received
|
||||
frame originates from a station known to transmit signals having
|
||||
little phase distortion (say, a station known to use a properly
|
||||
adjusted software-defined-transceiver) and if the received signal is
|
||||
relatively free from multipath distortion so that the channel phase is
|
||||
close to linear, the measured phase differences will be representative
|
||||
of the local receiver's phase response.
|
||||
|
||||
Complete the following steps to generate a phase equalization curve:
|
||||
|
||||
- Record a number of wav files that contain decodable signals from
|
||||
your chosen reference station. Best results will be obtained when the
|
||||
signal-to-noise ratio of the reference signals is 10 dB or greater.
|
||||
|
||||
- Enter the callsign of the reference station in the DX Call box.
|
||||
|
||||
- Select *Measure phase response* from the *Tools* menu, and open each
|
||||
of the wav files in turn. The mode character on decoded text lines
|
||||
will change from `&` to `^` while _WSJT-X_ is measuring the phase
|
||||
response, and it will change back to `&` after the measurement is
|
||||
completed. The program needs to average a number of high-SNR frames to
|
||||
accurately estimate the phase, so it may be necessary to process
|
||||
several wav files. The measurement can be aborted at any time by
|
||||
selecting *Measure phase response* again to toggle the phase
|
||||
measurement off.
|
||||
|
||||
+
|
||||
|
||||
When the measurement is complete _WSJT-X_ will save the measured
|
||||
phase response in the *Log directory*, in a file with suffix
|
||||
".pcoeff". The filename will contain the callsign of the reference
|
||||
station and a timestamp, for example `K0TPP_170923_112027.pcoeff`.
|
||||
|
||||
- Select *Equalization tools ...* under the *Tools* menu and click the
|
||||
*Phase ...* button to view the contents of the *Log directory*. Select
|
||||
the desired pcoeff file. The measured phase values will be plotted as
|
||||
filled circles along with a fitted red curve labeled "Proposed". This is
|
||||
the proposed phase equalization curve. It's a good idea to repeat the
|
||||
phase measurement several times, using different wav files for each
|
||||
measurement, to ensure that your measurements are repeatable.
|
||||
|
||||
- Once you are satisfied with a fitted curve, push the *Apply* button
|
||||
to save the proposed response. The red curve will be replaced with a
|
||||
light green curve labeled "Current" to indicate that the phase
|
||||
equalization curve is now being applied to the received data. Another
|
||||
curve labeled "Group Delay" will appear. The "Group Delay" curve shows
|
||||
the group delay variation across the passband, in ms. Click the
|
||||
*Discard* button to remove the captured data, leaving only the applied
|
||||
phase equalization curve and corresponding group delay curve.
|
||||
|
||||
- To revert to no phase equalization, push the *Restore Defaults*
|
||||
button followed by the *Apply* button.
|
||||
|
||||
The three numbers printed at the end of each MSK144 decode line can be
|
||||
used to assess the improvement provided by equalization. These numbers
|
||||
are: `N` = Number of frames averaged, `H` = Number of hard bit errors
|
||||
corrected, `E` = Size of MSK eye diagram opening.
|
||||
|
||||
Here is a decode of K0TPP obtained while *Measure phase response* was measuring
|
||||
the phase response:
|
||||
|
||||
103900 17 6.5 1493 ^ WA8CLT K0TPP +07 1 0 1.2
|
||||
|
||||
The "^" symbol indicates that a phase measurement is being accumulated
|
||||
but is not yet finished. The three numbers at the end of the line
|
||||
indicate that one frame was used to obtain the decode, there were no
|
||||
hard bit errors, and the eye-opening was 1.2 on a -2 to +2
|
||||
scale. Here's how the same decode looks after phase equalization:
|
||||
|
||||
103900 17 6.5 1493 & WA8CLT K0TPP +07 1 0 1.6
|
||||
|
||||
In this case, equalization has increased the eye opening from 1.2 to
|
||||
1.6. Larger positive eye openings are associated with reduced
|
||||
likelihood of bit errors and higher likelihood that a frame will be
|
||||
successfully decoded. In this case, the larger eye-opening tells us
|
||||
that phase equalization was successful, but it is important to note
|
||||
that this test does not by itself tell us whether the applied phase
|
||||
equalization curve is going to improve decoding of signals other than
|
||||
those from the reference station, K0TPP.
|
||||
|
||||
It's a good idea to carry out before and after comparisons using a
|
||||
large number of saved wav files with signals from many different
|
||||
stations, to help decide whether your equalization curve improves
|
||||
decoding for most signals. When doing such comparisons, keep in mind
|
||||
that equalization may cause _WSJT-X_ to successfully decode a frame
|
||||
that was not decoded before equalization was applied. For this
|
||||
reason, be sure that the time "T" of the two decodes are the same
|
||||
before comparing their end-of-line quality numbers.
|
||||
|
||||
When comparing before and after decodes having the same "T", keep in
|
||||
mind that a smaller first number means that decoding has improved,
|
||||
even if the second and third numbers appear to be "worse". For
|
||||
example, suppose that the end-of-line quality numbers before
|
||||
equalization are `2 0 0.2` and after equalization `1 5 -0.5`. These
|
||||
numbers show improved decoding because the decode was obtained using
|
||||
only a single frame after equalization whereas a 2-frame average was
|
||||
needed before equalization. This implies that shorter and/or weaker
|
||||
pings could be decodable.
|
||||
|
||||
NOTE: Further details on phase equalization and examples of fitted
|
||||
phase curves and eye diagrams can be found in the article on MSK144 by
|
||||
K9AN and K1JT published in {msk144}.
|
||||
@@ -0,0 +1,154 @@
|
||||
// Copyright (c) 2006 Xiaogang Zhang
|
||||
// Use, modification and distribution are subject to the
|
||||
// Boost Software License, Version 1.0. (See accompanying file
|
||||
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef BOOST_MATH_BESSEL_K1_HPP
|
||||
#define BOOST_MATH_BESSEL_K1_HPP
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#pragma once
|
||||
#pragma warning(push)
|
||||
#pragma warning(disable:4702) // Unreachable code (release mode only warning)
|
||||
#endif
|
||||
|
||||
#include <boost/math/tools/rational.hpp>
|
||||
#include <boost/math/tools/big_constant.hpp>
|
||||
#include <boost/math/policies/error_handling.hpp>
|
||||
#include <boost/assert.hpp>
|
||||
|
||||
// Modified Bessel function of the second kind of order one
|
||||
// minimax rational approximations on intervals, see
|
||||
// Russon and Blair, Chalk River Report AECL-3461, 1969
|
||||
|
||||
namespace boost { namespace math { namespace detail{
|
||||
|
||||
template <typename T, typename Policy>
|
||||
T bessel_k1(T x, const Policy&);
|
||||
|
||||
template <class T, class Policy>
|
||||
struct bessel_k1_initializer
|
||||
{
|
||||
struct init
|
||||
{
|
||||
init()
|
||||
{
|
||||
do_init();
|
||||
}
|
||||
static void do_init()
|
||||
{
|
||||
bessel_k1(T(1), Policy());
|
||||
}
|
||||
void force_instantiate()const{}
|
||||
};
|
||||
static const init initializer;
|
||||
static void force_instantiate()
|
||||
{
|
||||
initializer.force_instantiate();
|
||||
}
|
||||
};
|
||||
|
||||
template <class T, class Policy>
|
||||
const typename bessel_k1_initializer<T, Policy>::init bessel_k1_initializer<T, Policy>::initializer;
|
||||
|
||||
template <typename T, typename Policy>
|
||||
T bessel_k1(T x, const Policy& pol)
|
||||
{
|
||||
bessel_k1_initializer<T, Policy>::force_instantiate();
|
||||
|
||||
static const T P1[] = {
|
||||
static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -2.2149374878243304548e+06)),
|
||||
static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 7.1938920065420586101e+05)),
|
||||
static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 1.7733324035147015630e+05)),
|
||||
static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 7.1885382604084798576e+03)),
|
||||
static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 9.9991373567429309922e+01)),
|
||||
static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 4.8127070456878442310e-01))
|
||||
};
|
||||
static const T Q1[] = {
|
||||
static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -2.2149374878243304548e+06)),
|
||||
static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 3.7264298672067697862e+04)),
|
||||
static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -2.8143915754538725829e+02)),
|
||||
static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 1.0))
|
||||
};
|
||||
static const T P2[] = {
|
||||
static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 0.0)),
|
||||
static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -1.3531161492785421328e+06)),
|
||||
static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -1.4758069205414222471e+05)),
|
||||
static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -4.5051623763436087023e+03)),
|
||||
static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -5.3103913335180275253e+01)),
|
||||
static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -2.2795590826955002390e-01))
|
||||
};
|
||||
static const T Q2[] = {
|
||||
static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -2.7062322985570842656e+06)),
|
||||
static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 4.3117653211351080007e+04)),
|
||||
static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -3.0507151578787595807e+02)),
|
||||
static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 1.0))
|
||||
};
|
||||
static const T P3[] = {
|
||||
static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 2.2196792496874548962e+00)),
|
||||
static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 4.4137176114230414036e+01)),
|
||||
static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 3.4122953486801312910e+02)),
|
||||
static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 1.3319486433183221990e+03)),
|
||||
static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 2.8590657697910288226e+03)),
|
||||
static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 3.4540675585544584407e+03)),
|
||||
static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 2.3123742209168871550e+03)),
|
||||
static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 8.1094256146537402173e+02)),
|
||||
static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 1.3182609918569941308e+02)),
|
||||
static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 7.5584584631176030810e+00)),
|
||||
static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 6.4257745859173138767e-02))
|
||||
};
|
||||
static const T Q3[] = {
|
||||
static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 1.7710478032601086579e+00)),
|
||||
static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 3.4552228452758912848e+01)),
|
||||
static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 2.5951223655579051357e+02)),
|
||||
static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 9.6929165726802648634e+02)),
|
||||
static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 1.9448440788918006154e+03)),
|
||||
static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 2.1181000487171943810e+03)),
|
||||
static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 1.2082692316002348638e+03)),
|
||||
static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 3.3031020088765390854e+02)),
|
||||
static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 3.6001069306861518855e+01)),
|
||||
static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 1.0))
|
||||
};
|
||||
T value, factor, r, r1, r2;
|
||||
|
||||
BOOST_MATH_STD_USING
|
||||
using namespace boost::math::tools;
|
||||
|
||||
static const char* function = "boost::math::bessel_k1<%1%>(%1%,%1%)";
|
||||
|
||||
if (x < 0)
|
||||
{
|
||||
return policies::raise_domain_error<T>(function,
|
||||
"Got x = %1%, but argument x must be non-negative, complex number result not supported.", x, pol);
|
||||
}
|
||||
if (x == 0)
|
||||
{
|
||||
return policies::raise_overflow_error<T>(function, 0, pol);
|
||||
}
|
||||
if (x <= 1) // x in (0, 1]
|
||||
{
|
||||
T y = x * x;
|
||||
r1 = evaluate_polynomial(P1, y) / evaluate_polynomial(Q1, y);
|
||||
r2 = evaluate_polynomial(P2, y) / evaluate_polynomial(Q2, y);
|
||||
factor = log(x);
|
||||
value = (r1 + factor * r2) / x;
|
||||
}
|
||||
else // x in (1, \infty)
|
||||
{
|
||||
T y = 1 / x;
|
||||
r = evaluate_polynomial(P3, y) / evaluate_polynomial(Q3, y);
|
||||
factor = exp(-x) / sqrt(x);
|
||||
value = factor * r;
|
||||
}
|
||||
|
||||
return value;
|
||||
}
|
||||
|
||||
}}} // namespaces
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
#endif // BOOST_MATH_BESSEL_K1_HPP
|
||||
|
||||
@@ -0,0 +1,106 @@
|
||||
#if !defined(BOOST_PP_IS_ITERATING)
|
||||
|
||||
// Copyright David Abrahams 2002.
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
# ifndef SIGNATURE_DWA20021121_HPP
|
||||
# define SIGNATURE_DWA20021121_HPP
|
||||
|
||||
# include <boost/python/type_id.hpp>
|
||||
|
||||
# include <boost/python/detail/preprocessor.hpp>
|
||||
# include <boost/python/detail/indirect_traits.hpp>
|
||||
# include <boost/python/converter/pytype_function.hpp>
|
||||
|
||||
# include <boost/preprocessor/iterate.hpp>
|
||||
# include <boost/preprocessor/iteration/local.hpp>
|
||||
|
||||
# include <boost/mpl/at.hpp>
|
||||
# include <boost/mpl/size.hpp>
|
||||
|
||||
namespace boost { namespace python { namespace detail {
|
||||
|
||||
struct signature_element
|
||||
{
|
||||
char const* basename;
|
||||
converter::pytype_function pytype_f;
|
||||
bool lvalue;
|
||||
};
|
||||
|
||||
struct py_func_sig_info
|
||||
{
|
||||
signature_element const *signature;
|
||||
signature_element const *ret;
|
||||
};
|
||||
|
||||
template <unsigned> struct signature_arity;
|
||||
|
||||
# define BOOST_PP_ITERATION_PARAMS_1 \
|
||||
(3, (0, BOOST_PYTHON_MAX_ARITY + 1, <boost/python/detail/signature.hpp>))
|
||||
# include BOOST_PP_ITERATE()
|
||||
|
||||
// A metafunction returning the base class used for
|
||||
//
|
||||
// signature<class F, class CallPolicies, class Sig>.
|
||||
//
|
||||
template <class Sig>
|
||||
struct signature_base_select
|
||||
{
|
||||
enum { arity = mpl::size<Sig>::value - 1 };
|
||||
typedef typename signature_arity<arity>::template impl<Sig> type;
|
||||
};
|
||||
|
||||
template <class Sig>
|
||||
struct signature
|
||||
: signature_base_select<Sig>::type
|
||||
{
|
||||
};
|
||||
|
||||
}}} // namespace boost::python::detail
|
||||
|
||||
# endif // SIGNATURE_DWA20021121_HPP
|
||||
|
||||
#else
|
||||
|
||||
# define N BOOST_PP_ITERATION()
|
||||
|
||||
template <>
|
||||
struct signature_arity<N>
|
||||
{
|
||||
template <class Sig>
|
||||
struct impl
|
||||
{
|
||||
static signature_element const* elements()
|
||||
{
|
||||
static signature_element const result[N+2] = {
|
||||
|
||||
#ifndef BOOST_PYTHON_NO_PY_SIGNATURES
|
||||
# define BOOST_PP_LOCAL_MACRO(i) \
|
||||
{ \
|
||||
type_id<BOOST_DEDUCED_TYPENAME mpl::at_c<Sig,i>::type>().name() \
|
||||
, &converter::expected_pytype_for_arg<BOOST_DEDUCED_TYPENAME mpl::at_c<Sig,i>::type>::get_pytype \
|
||||
, indirect_traits::is_reference_to_non_const<BOOST_DEDUCED_TYPENAME mpl::at_c<Sig,i>::type>::value \
|
||||
},
|
||||
#else
|
||||
# define BOOST_PP_LOCAL_MACRO(i) \
|
||||
{ \
|
||||
type_id<BOOST_DEDUCED_TYPENAME mpl::at_c<Sig,i>::type>().name() \
|
||||
, 0 \
|
||||
, indirect_traits::is_reference_to_non_const<BOOST_DEDUCED_TYPENAME mpl::at_c<Sig,i>::type>::value \
|
||||
},
|
||||
#endif
|
||||
|
||||
# define BOOST_PP_LOCAL_LIMITS (0, N)
|
||||
# include BOOST_PP_LOCAL_ITERATE()
|
||||
{0,0,0}
|
||||
};
|
||||
return result;
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
#endif // BOOST_PP_IS_ITERATING
|
||||
|
||||
|
||||
@@ -0,0 +1,74 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2001-2007 Joel de Guzman
|
||||
|
||||
Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
==============================================================================*/
|
||||
|
||||
#if !BOOST_PHOENIX_IS_ITERATING
|
||||
|
||||
#include <boost/phoenix/core/expression.hpp>
|
||||
#include <boost/phoenix/core/detail/function_eval.hpp>
|
||||
|
||||
namespace boost { namespace phoenix {
|
||||
template <typename F>
|
||||
inline
|
||||
typename detail::expression::function_eval<F>::type const
|
||||
bind(F f)
|
||||
{
|
||||
return detail::expression::function_eval<F>::make(f);
|
||||
}
|
||||
|
||||
#if !defined(BOOST_PHOENIX_DONT_USE_PREPROCESSED_FILES)
|
||||
#include <boost/phoenix/bind/detail/cpp03/preprocessed/bind_function_object.hpp>
|
||||
#else
|
||||
|
||||
#if defined(__WAVE__) && defined (BOOST_PHOENIX_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 2, line: 0, output: "preprocessed/bind_function_object_" BOOST_PHOENIX_LIMIT_STR ".hpp")
|
||||
#endif
|
||||
|
||||
/*=============================================================================
|
||||
Copyright (c) 2001-2007 Joel de Guzman
|
||||
|
||||
Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
==============================================================================*/
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PHOENIX_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 1)
|
||||
#endif
|
||||
|
||||
#define BOOST_PHOENIX_ITERATION_PARAMS \
|
||||
(3, (1, BOOST_PP_DEC(BOOST_PHOENIX_ACTOR_LIMIT), \
|
||||
<boost/phoenix/bind/detail/cpp03/bind_function_object.hpp>))
|
||||
#include BOOST_PHOENIX_ITERATE()
|
||||
|
||||
#if defined(__WAVE__) && defined (BOOST_PHOENIX_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(output: null)
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
}}
|
||||
|
||||
#else
|
||||
|
||||
template <
|
||||
typename F
|
||||
, BOOST_PHOENIX_typename_A
|
||||
>
|
||||
inline
|
||||
typename detail::expression::function_eval<
|
||||
F
|
||||
, BOOST_PHOENIX_A
|
||||
>::type const
|
||||
bind(F f, BOOST_PHOENIX_A_const_ref_a)
|
||||
{
|
||||
return
|
||||
detail::expression::function_eval<F, BOOST_PHOENIX_A>::make(
|
||||
f
|
||||
, BOOST_PHOENIX_a
|
||||
);
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,66 @@
|
||||
program QRA64code
|
||||
|
||||
! Provides examples of message packing, bit and symbol ordering,
|
||||
! QRA (63,12) encoding, and other necessary details of the QRA64
|
||||
! protocol.
|
||||
|
||||
use packjt
|
||||
character*22 msg,msg0,msg1,decoded,cok*3,msgtype*10,arg*12
|
||||
character*6 mycall
|
||||
logical ltext
|
||||
integer dgen(12),sent(63),dec(12)
|
||||
integer icos7(0:6)
|
||||
data icos7/2,5,6,0,4,1,3/ !Defines a 7x7 Costas array
|
||||
|
||||
include 'testmsg.f90'
|
||||
|
||||
nargs=iargc()
|
||||
if(nargs.lt.1) then
|
||||
print*,'Usage: qra64code "message"'
|
||||
print*,' qra64code -t'
|
||||
go to 999
|
||||
endif
|
||||
|
||||
call getarg(1,msg) !Get message from command line
|
||||
nmsg=1
|
||||
if(msg(1:2).eq."-t") nmsg=NTEST
|
||||
|
||||
write(*,1010)
|
||||
1010 format(" Message Decoded Err? Type"/74("-"))
|
||||
|
||||
do imsg=1,nmsg
|
||||
if(nmsg.gt.1) msg=testmsg(imsg)
|
||||
call fmtmsg(msg,iz) !To upper, collapse mult blanks
|
||||
msg0=msg !Input message
|
||||
call chkmsg(msg,cok,nspecial,flip) !See if it includes "OOO" report
|
||||
msg1=msg !Message without "OOO"
|
||||
call packmsg(msg1,dgen,itype) !Pack message into 12 six-bit bytes
|
||||
msgtype=""
|
||||
if(itype.eq.1) msgtype="Std Msg"
|
||||
if(itype.eq.2) msgtype="Type 1 pfx"
|
||||
if(itype.eq.3) msgtype="Type 1 sfx"
|
||||
if(itype.eq.4) msgtype="Type 2 pfx"
|
||||
if(itype.eq.5) msgtype="Type 2 sfx"
|
||||
if(itype.eq.6) msgtype="Free text"
|
||||
|
||||
call qra64_enc(dgen,sent) !Encode using QRA64
|
||||
|
||||
call unpackmsg(dgen,decoded) !Unpack the user message
|
||||
call fmtmsg(decoded,iz)
|
||||
ii=imsg
|
||||
write(*,1020) ii,msg0,decoded,itype,msgtype
|
||||
1020 format(i4,1x,a22,2x,a22,4x,i3,": ",a13)
|
||||
enddo
|
||||
|
||||
if(nmsg.eq.1) then
|
||||
write(*,1030) dgen
|
||||
1030 format(/'Packed message, 6-bit symbols ',12i3) !Display packed symbols
|
||||
|
||||
write(*,1040) sent
|
||||
1040 format(/'Information-carrying channel symbols'/(i5,29i3))
|
||||
|
||||
write(*,1050) 10*icos7,sent(1:32),10*icos7,sent(33:63),10*icos7
|
||||
1050 format(/'Channel symbols including sync'/(i5,29i3))
|
||||
endif
|
||||
|
||||
999 end program QRA64code
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 9.9 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 80 KiB |
@@ -0,0 +1,73 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2011 Thomas Heller
|
||||
|
||||
Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
==============================================================================*/
|
||||
#if !BOOST_PHOENIX_IS_ITERATING
|
||||
|
||||
template <typename F, BOOST_PHOENIX_typename_A_void(BOOST_PP_DEC(BOOST_PHOENIX_COMPOSITE_LIMIT)), typename Dummy = void>
|
||||
struct has_phx2_result
|
||||
: mpl::false_
|
||||
{};
|
||||
|
||||
template <typename F, BOOST_PHOENIX_typename_A_void(BOOST_PP_DEC(BOOST_PHOENIX_COMPOSITE_LIMIT)), typename Dummy = void>
|
||||
struct phx2_result;
|
||||
|
||||
#if !defined(BOOST_PHOENIX_DONT_USE_PREPROCESSED_FILES)
|
||||
#include <boost/phoenix/core/detail/cpp03/preprocessed/phx2_result.hpp>
|
||||
#else
|
||||
#if defined(__WAVE__) && defined(BOOST_PHOENIX_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 2, line: 0, output: "preprocessed/phx2_result_" BOOST_PHOENIX_LIMIT_STR ".hpp")
|
||||
#endif
|
||||
/*=============================================================================
|
||||
Copyright (c) 2011 Thomas Heller
|
||||
|
||||
Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
==============================================================================*/
|
||||
#if defined(__WAVE__) && defined(BOOST_PHOENIX_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(preserve: 1)
|
||||
#endif
|
||||
|
||||
#define BOOST_PHOENIX_ITERATION_PARAMS \
|
||||
(3, (1, BOOST_PP_DEC(BOOST_PHOENIX_COMPOSITE_LIMIT), \
|
||||
<boost/phoenix/core/detail/cpp03/phx2_result.hpp>))
|
||||
#include BOOST_PHOENIX_ITERATE()
|
||||
|
||||
#if defined(__WAVE__) && defined(BOOST_PHOENIX_CREATE_PREPROCESSED_FILES)
|
||||
#pragma wave option(output: null)
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
#else
|
||||
|
||||
template <typename F, BOOST_PHOENIX_typename_A>
|
||||
struct has_phx2_result<F, BOOST_PHOENIX_A>
|
||||
: mpl::eval_if<
|
||||
has_result_type<F>
|
||||
, mpl::false_
|
||||
, has_phx2_result_impl<typename F::template result<F(BOOST_PHOENIX_A)> >
|
||||
>::type
|
||||
{};
|
||||
|
||||
template <typename F, BOOST_PHOENIX_typename_A>
|
||||
struct phx2_result<F, BOOST_PHOENIX_A>
|
||||
{
|
||||
typedef typename F::template result<BOOST_PHOENIX_A>::type type;
|
||||
};
|
||||
|
||||
template <typename F, BOOST_PHOENIX_typename_A>
|
||||
struct phx2_result<F, BOOST_PHOENIX_A_ref>
|
||||
{
|
||||
typedef typename F::template result<BOOST_PHOENIX_A>::type type;
|
||||
};
|
||||
|
||||
template <typename F, BOOST_PHOENIX_typename_A>
|
||||
struct phx2_result<F, BOOST_PHOENIX_A_const_ref>
|
||||
{
|
||||
typedef typename F::template result<BOOST_PHOENIX_A>::type type;
|
||||
};
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,45 @@
|
||||
// Boost.Assign library
|
||||
//
|
||||
// Copyright Thorsten Ottosen 2003-2004. Use, modification and
|
||||
// distribution is subject to the Boost Software License, Version
|
||||
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
// For more information, see http://www.boost.org/libs/assign/
|
||||
//
|
||||
|
||||
#ifndef BOOST_ASSIGN_STD_SLIST_HPP
|
||||
#define BOOST_ASSIGN_STD_SLIST_HPP
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#ifdef BOOST_HAS_SLIST
|
||||
|
||||
#if defined(_MSC_VER)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
#include <boost/assign/list_inserter.hpp>
|
||||
#ifdef BOOST_SLIST_HEADER
|
||||
# include BOOST_SLIST_HEADER
|
||||
#else
|
||||
# include <slist>
|
||||
#endif
|
||||
|
||||
namespace boost
|
||||
{
|
||||
namespace assign
|
||||
{
|
||||
|
||||
template< class V, class A, class V2 >
|
||||
inline list_inserter< assign_detail::call_push_back< BOOST_STD_EXTENSION_NAMESPACE::slist<V,A> >, V >
|
||||
operator+=( BOOST_STD_EXTENSION_NAMESPACE::slist<V,A>& c, V2 v )
|
||||
{
|
||||
return push_back( c )( v );
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
#endif // BOOST_HAS_SLIST
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,113 @@
|
||||
/* MOD2DENSE.H - Interface to module for handling dense mod2 matrices. */
|
||||
|
||||
/* Copyright (c) 1995-2012 by Radford M. Neal.
|
||||
*
|
||||
* Permission is granted for anyone to copy, use, modify, and distribute
|
||||
* these programs and accompanying documents for any purpose, provided
|
||||
* this copyright notice is retained and prominently displayed, and note
|
||||
* is made of any changes made to these programs. These programs and
|
||||
* documents are distributed without any warranty, express or implied.
|
||||
* As the programs were written for research purposes only, they have not
|
||||
* been tested to the degree that would be advisable in any important
|
||||
* application. All use of these programs is entirely at the user's own
|
||||
* risk.
|
||||
*/
|
||||
|
||||
|
||||
/* This module implements operations on matrices of mod2 elements (bits,
|
||||
with addition and multiplication being done modulo 2). The matrices
|
||||
are stored with consecutive bits of a column packed into words, and
|
||||
the procedures are implemented where possible using bit operations
|
||||
on these words. This is an appropriate representation when the matrices
|
||||
are dense (ie, 0s and 1s are about equally frequent).
|
||||
|
||||
All procedures in this module display an error message on standard
|
||||
error and terminate the program if passed an invalid argument (indicative
|
||||
of a programming error), or if memory cannot be allocated. Errors from
|
||||
invalid contents of a file result in an error code being returned to the
|
||||
caller, with no message being printed by this module.
|
||||
*/
|
||||
|
||||
|
||||
#include <stdint.h> /* Has the definition of uint32_t used below */
|
||||
|
||||
/* PACKING OF BITS INTO WORDS. Bits are packed into 32-bit words, with
|
||||
the low-order bit coming first. */
|
||||
|
||||
typedef uint32_t mod2word; /* Data type that holds packed bits. If uint32_t
|
||||
doesn't exist, change it to unsigned long */
|
||||
|
||||
#define mod2_wordsize 32 /* Number of bits that fit in a mod2word. Can't
|
||||
be increased without changing intio module */
|
||||
|
||||
#define mod2_wordsize_shift 5 /* Amount to shift by to divide by wordsize */
|
||||
#define mod2_wordsize_mask 0x1f /* What to AND with to produce mod wordsize */
|
||||
|
||||
/* Extract the i'th bit of a mod2word. */
|
||||
|
||||
#define mod2_getbit(w,i) (((w)>>(i))&1)
|
||||
|
||||
/* Make a word like w, but with the i'th bit set to 1 (if it wasn't already). */
|
||||
|
||||
#define mod2_setbit1(w,i) ((w)|(1<<(i)))
|
||||
|
||||
/* Make a word like w, but with the i'th bit set to 0 (if it wasn't already). */
|
||||
|
||||
#define mod2_setbit0(w,i) ((w)&(~(1<<(i))))
|
||||
|
||||
|
||||
/* STRUCTURE REPRESENTING A DENSE MATRIX. These structures are dynamically
|
||||
allocated using mod2dense_allocate (or by other procedures that call
|
||||
mod2dense_allocate). They should be freed with mod2dense_free when no
|
||||
longer required.
|
||||
|
||||
Direct access to this structure should be avoided except in low-level
|
||||
routines. Use the macros and procedures defined below instead. */
|
||||
|
||||
typedef struct
|
||||
{
|
||||
int n_rows; /* Number of rows in the matrix */
|
||||
int n_cols; /* Number of columns in the matrix */
|
||||
|
||||
int n_words; /* Number of words used to store a column of bits */
|
||||
|
||||
mod2word **col; /* Pointer to array of pointers to columns */
|
||||
|
||||
mod2word *bits; /* Pointer to storage block for bits in this matrix
|
||||
(pieces of this block are pointed to from col) */
|
||||
} mod2dense;
|
||||
|
||||
|
||||
/* MACROS. */
|
||||
|
||||
#define mod2dense_rows(m) ((m)->n_rows) /* Get the number of rows or columns */
|
||||
#define mod2dense_cols(m) ((m)->n_cols) /* in a matrix */
|
||||
|
||||
|
||||
/* PROCEDURES. */
|
||||
|
||||
mod2dense *mod2dense_allocate (int, int);
|
||||
void mod2dense_free (mod2dense *);
|
||||
|
||||
void mod2dense_clear (mod2dense *);
|
||||
void mod2dense_copy (mod2dense *, mod2dense *);
|
||||
void mod2dense_copyrows (mod2dense*, mod2dense *, int *);
|
||||
void mod2dense_copycols (mod2dense*, mod2dense *, int *);
|
||||
|
||||
void mod2dense_print (FILE *, mod2dense *);
|
||||
int mod2dense_write (FILE *, mod2dense *);
|
||||
mod2dense *mod2dense_read (FILE *);
|
||||
|
||||
int mod2dense_get (mod2dense *, int, int);
|
||||
void mod2dense_set (mod2dense *, int, int, int);
|
||||
int mod2dense_flip(mod2dense *, int, int);
|
||||
|
||||
void mod2dense_transpose (mod2dense *, mod2dense *);
|
||||
void mod2dense_add (mod2dense *, mod2dense *, mod2dense *);
|
||||
void mod2dense_multiply (mod2dense *, mod2dense *, mod2dense *);
|
||||
|
||||
int mod2dense_equal (mod2dense *, mod2dense *);
|
||||
|
||||
int mod2dense_invert (mod2dense *, mod2dense *);
|
||||
int mod2dense_forcibly_invert (mod2dense *, mod2dense *, int *, int *);
|
||||
int mod2dense_invert_selected (mod2dense *, mod2dense *, int *, int *);
|
||||
@@ -0,0 +1,117 @@
|
||||
// Copyright Jim Bosch 2010-2012.
|
||||
// Copyright Stefan Seefeld 2016.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef boost_python_numpy_dtype_hpp_
|
||||
#define boost_python_numpy_dtype_hpp_
|
||||
|
||||
/**
|
||||
* @file boost/python/numpy/dtype.hpp
|
||||
* @brief Object manager for Python's numpy.dtype class.
|
||||
*/
|
||||
|
||||
#include <boost/python.hpp>
|
||||
#include <boost/python/numpy/numpy_object_mgr_traits.hpp>
|
||||
|
||||
#include <boost/mpl/for_each.hpp>
|
||||
#include <boost/type_traits/add_pointer.hpp>
|
||||
|
||||
namespace boost { namespace python { namespace numpy {
|
||||
|
||||
/**
|
||||
* @brief A boost.python "object manager" (subclass of object) for numpy.dtype.
|
||||
*
|
||||
* @todo This could have a lot more interesting accessors.
|
||||
*/
|
||||
class dtype : public object {
|
||||
static python::detail::new_reference convert(object::object_cref arg, bool align);
|
||||
public:
|
||||
|
||||
/// @brief Convert an arbitrary Python object to a data-type descriptor object.
|
||||
template <typename T>
|
||||
explicit dtype(T arg, bool align=false) : object(convert(arg, align)) {}
|
||||
|
||||
/**
|
||||
* @brief Get the built-in numpy dtype associated with the given scalar template type.
|
||||
*
|
||||
* This is perhaps the most useful part of the numpy API: it returns the dtype object
|
||||
* corresponding to a built-in C++ type. This should work for any integer or floating point
|
||||
* type supported by numpy, and will also work for std::complex if
|
||||
* sizeof(std::complex<T>) == 2*sizeof(T).
|
||||
*
|
||||
* It can also be useful for users to add explicit specializations for POD structs
|
||||
* that return field-based dtypes.
|
||||
*/
|
||||
template <typename T> static dtype get_builtin();
|
||||
|
||||
/// @brief Return the size of the data type in bytes.
|
||||
int get_itemsize() const;
|
||||
|
||||
/**
|
||||
* @brief Compare two dtypes for equivalence.
|
||||
*
|
||||
* This is more permissive than equality tests. For instance, if long and int are the same
|
||||
* size, the dtypes corresponding to each will be equivalent, but not equal.
|
||||
*/
|
||||
friend bool equivalent(dtype const & a, dtype const & b);
|
||||
|
||||
/**
|
||||
* @brief Register from-Python converters for NumPy's built-in array scalar types.
|
||||
*
|
||||
* This is usually called automatically by initialize(), and shouldn't be called twice
|
||||
* (doing so just adds unused converters to the Boost.Python registry).
|
||||
*/
|
||||
static void register_scalar_converters();
|
||||
|
||||
BOOST_PYTHON_FORWARD_OBJECT_CONSTRUCTORS(dtype, object);
|
||||
|
||||
};
|
||||
|
||||
bool equivalent(dtype const & a, dtype const & b);
|
||||
|
||||
namespace detail
|
||||
{
|
||||
|
||||
template <int bits, bool isUnsigned> dtype get_int_dtype();
|
||||
|
||||
template <int bits> dtype get_float_dtype();
|
||||
|
||||
template <int bits> dtype get_complex_dtype();
|
||||
|
||||
template <typename T, bool isInt=boost::is_integral<T>::value>
|
||||
struct builtin_dtype;
|
||||
|
||||
template <typename T>
|
||||
struct builtin_dtype<T,true> {
|
||||
static dtype get() { return get_int_dtype< 8*sizeof(T), boost::is_unsigned<T>::value >(); }
|
||||
};
|
||||
|
||||
template <>
|
||||
struct builtin_dtype<bool,true> {
|
||||
static dtype get();
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
struct builtin_dtype<T,false> {
|
||||
static dtype get() { return get_float_dtype< 8*sizeof(T) >(); }
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
struct builtin_dtype< std::complex<T>, false > {
|
||||
static dtype get() { return get_complex_dtype< 16*sizeof(T) >(); }
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
template <typename T>
|
||||
inline dtype dtype::get_builtin() { return detail::builtin_dtype<T>::get(); }
|
||||
|
||||
} // namespace boost::python::numpy
|
||||
|
||||
namespace converter {
|
||||
NUMPY_OBJECT_MANAGER_TRAITS(numpy::dtype);
|
||||
}}} // namespace boost::python::converter
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,116 @@
|
||||
subroutine avecho(id2,ndop,nfrit,nqual,f1,xlevel,sigdb,snr,dfreq,width)
|
||||
|
||||
integer TXLENGTH
|
||||
parameter (TXLENGTH=27648) !27*1024
|
||||
parameter (NFFT=32768,NH=NFFT/2)
|
||||
parameter (NZ=4096)
|
||||
integer*2 id2(34560) !Buffer for Rx data
|
||||
real sa(NZ) !Avg spectrum relative to initial Doppler echo freq
|
||||
real sb(NZ) !Avg spectrum with Dither and changing Doppler removed
|
||||
integer nsum !Number of integrations
|
||||
real dop0 !Doppler shift for initial integration (Hz)
|
||||
real dop !Doppler shift for current integration (Hz)
|
||||
real s(8192)
|
||||
real x(NFFT)
|
||||
integer ipkv(1)
|
||||
complex c(0:NH)
|
||||
equivalence (x,c),(ipk,ipkv)
|
||||
common/echocom/nclearave,nsum,blue(NZ),red(NZ)
|
||||
save dop0,sa,sb
|
||||
|
||||
dop=ndop
|
||||
sq=0.
|
||||
do i=1,TXLENGTH
|
||||
x(i)=id2(i)
|
||||
sq=sq + x(i)*x(i)
|
||||
enddo
|
||||
xlevel=10.0*log10(sq/TXLENGTH)
|
||||
|
||||
if(nclearave.ne.0) nsum=0
|
||||
if(nsum.eq.0) then
|
||||
dop0=dop !Remember the initial Doppler
|
||||
sa=0. !Clear the average arrays
|
||||
sb=0.
|
||||
endif
|
||||
|
||||
x(TXLENGTH+1:)=0.
|
||||
x=x/TXLENGTH
|
||||
call four2a(x,NFFT,1,-1,0)
|
||||
df=12000.0/NFFT
|
||||
do i=1,8192 !Get spectrum 0 - 3 kHz
|
||||
s(i)=real(c(i))**2 + aimag(c(i))**2
|
||||
enddo
|
||||
|
||||
fnominal=1500.0 !Nominal audio frequency w/o doppler or dither
|
||||
ia=nint((fnominal+dop0-nfrit)/df)
|
||||
ib=nint((f1+dop-nfrit)/df)
|
||||
if(ia.lt.600 .or. ib.lt.600) go to 900
|
||||
if(ia.gt.7590 .or. ib.gt.7590) go to 900
|
||||
|
||||
nsum=nsum+1
|
||||
|
||||
do i=1,NZ
|
||||
sa(i)=sa(i) + s(ia+i-2048) !Center at initial doppler freq
|
||||
sb(i)=sb(i) + s(ib+i-2048) !Center at expected echo freq
|
||||
enddo
|
||||
|
||||
call pctile(sb,200,50,r0)
|
||||
call pctile(sb(1800),200,50,r1)
|
||||
|
||||
sum=0.
|
||||
sq=0.
|
||||
do i=1,NZ
|
||||
y=r0 + (r1-r0)*(i-100.0)/1800.0
|
||||
blue(i)=sa(i)/y
|
||||
red(i)=sb(i)/y
|
||||
if(i.le.500 .or. i.ge.3597) then
|
||||
sum=sum+red(i)
|
||||
sq=sq + (red(i)-1.0)**2
|
||||
endif
|
||||
enddo
|
||||
ave=sum/1000.0
|
||||
rms=sqrt(sq/1000.0)
|
||||
|
||||
redmax=maxval(red)
|
||||
ipkv=maxloc(red)
|
||||
fac=10.0/max(redmax,10.0)
|
||||
dfreq=(ipk-2048)*df
|
||||
snr=(redmax-ave)/rms
|
||||
|
||||
sigdb=-99.0
|
||||
if(ave.gt.0.0) sigdb=10.0*log10(redmax/ave - 1.0) - 35.7
|
||||
|
||||
nqual=0
|
||||
if(nsum.ge.2 .and. nsum.lt.4) nqual=(snr-4)/5
|
||||
if(nsum.ge.4 .and. nsum.lt.8) nqual=(snr-3)/4
|
||||
if(nsum.ge.8 .and. nsum.lt.12) nqual=(snr-3)/3
|
||||
if(nsum.ge.12) nqual=(snr-2.5)/2.5
|
||||
if(nqual.lt.0) nqual=0
|
||||
if(nqual.gt.10) nqual=10
|
||||
|
||||
! Scale for plotting
|
||||
blue=fac*blue
|
||||
red=fac*red
|
||||
|
||||
sum=0.
|
||||
do i=ipk,ipk+300
|
||||
if(i.gt.NZ) exit
|
||||
if(red(i).lt.1.0) exit
|
||||
sum=sum+(red(i)-1.0)
|
||||
enddo
|
||||
do i=ipk-1,ipk-300,-1
|
||||
if(i.lt.1) exit
|
||||
if(red(i).lt.1.0) exit
|
||||
sum=sum+(red(i)-1.0)
|
||||
enddo
|
||||
bins=sum/(red(ipk)-1.0)
|
||||
width=df*bins
|
||||
nsmo=max(0.0,0.25*bins)
|
||||
|
||||
do i=1,nsmo
|
||||
call smo121(red,NZ)
|
||||
call smo121(blue,NZ)
|
||||
enddo
|
||||
|
||||
900 return
|
||||
end subroutine avecho
|
||||
@@ -0,0 +1,107 @@
|
||||
// Boost.Units - A C++ library for zero-overhead dimensional analysis and
|
||||
// unit/quantity manipulation and conversion
|
||||
//
|
||||
// Copyright (C) 2003-2008 Matthias Christian Schabel
|
||||
// Copyright (C) 2007-2008 Steven Watanabe
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
/// \file
|
||||
/// \brief base dimensions (mass, length, time...).
|
||||
/// \details base dimension definition registration.
|
||||
|
||||
#ifndef BOOST_UNITS_BASE_DIMENSION_HPP
|
||||
#define BOOST_UNITS_BASE_DIMENSION_HPP
|
||||
|
||||
#include <boost/units/config.hpp>
|
||||
#include <boost/units/dim.hpp>
|
||||
#include <boost/units/static_rational.hpp>
|
||||
#include <boost/units/units_fwd.hpp>
|
||||
#include <boost/units/detail/dimension_list.hpp>
|
||||
#include <boost/units/detail/ordinal.hpp>
|
||||
#include <boost/units/detail/prevent_redefinition.hpp>
|
||||
|
||||
namespace boost {
|
||||
|
||||
namespace units {
|
||||
|
||||
/// This must be in namespace boost::units so that ADL
|
||||
/// will work with friend functions defined inline.
|
||||
/// INTERNAL ONLY
|
||||
template<long N> struct base_dimension_ordinal { };
|
||||
|
||||
/// INTERNAL ONLY
|
||||
template<class T, long N> struct base_dimension_pair { };
|
||||
|
||||
/// INTERNAL ONLY
|
||||
template<class T, long N>
|
||||
struct check_base_dimension {
|
||||
enum {
|
||||
value =
|
||||
sizeof(boost_units_is_registered(units::base_dimension_ordinal<N>())) == sizeof(detail::yes) &&
|
||||
sizeof(boost_units_is_registered(units::base_dimension_pair<T, N>())) != sizeof(detail::yes)
|
||||
};
|
||||
};
|
||||
|
||||
/// Defines a base dimension. To define a dimension you need to provide
|
||||
/// the derived class (CRTP) and a unique integer.
|
||||
/// @code
|
||||
/// struct my_dimension : boost::units::base_dimension<my_dimension, 1> {};
|
||||
/// @endcode
|
||||
/// It is designed so that you will get an error message if you try
|
||||
/// to use the same value in multiple definitions.
|
||||
template<class Derived,
|
||||
long N
|
||||
#if !defined(BOOST_UNITS_DOXYGEN) && !defined(__BORLANDC__)
|
||||
,
|
||||
class = typename detail::ordinal_has_already_been_defined<
|
||||
check_base_dimension<Derived, N>::value
|
||||
>::type
|
||||
#endif
|
||||
>
|
||||
class base_dimension :
|
||||
public ordinal<N>
|
||||
{
|
||||
public:
|
||||
/// INTERNAL ONLY
|
||||
typedef base_dimension this_type;
|
||||
/// A convenience typedef. Equivalent to boost::units::derived_dimension<Derived,1>::type.
|
||||
#ifndef BOOST_UNITS_DOXYGEN
|
||||
typedef list<dim<Derived,static_rational<1> >, dimensionless_type> dimension_type;
|
||||
#else
|
||||
typedef detail::unspecified dimension_type;
|
||||
#endif
|
||||
/// Provided for mpl compatability.
|
||||
typedef Derived type;
|
||||
|
||||
private:
|
||||
/// Check for C++0x. In C++0x, we have to have identical
|
||||
/// arguments but a different return type to trigger an
|
||||
/// error. Note that this is only needed for clang as
|
||||
/// check_base_dimension will trigger an error earlier
|
||||
/// for compilers with less strict name lookup.
|
||||
/// INTERNAL ONLY
|
||||
friend Derived*
|
||||
check_double_register(const units::base_dimension_ordinal<N>&)
|
||||
{ return(0); }
|
||||
|
||||
/// Register this ordinal
|
||||
/// INTERNAL ONLY
|
||||
friend detail::yes
|
||||
boost_units_is_registered(const units::base_dimension_ordinal<N>&)
|
||||
{ detail::yes result; return(result); }
|
||||
|
||||
/// But make sure we can identify the current instantiation!
|
||||
/// INTERNAL ONLY
|
||||
friend detail::yes
|
||||
boost_units_is_registered(const units::base_dimension_pair<Derived, N>&)
|
||||
{ detail::yes result; return(result); }
|
||||
};
|
||||
|
||||
} // namespace units
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_UNITS_BASE_DIMENSION_HPP
|
||||
@@ -0,0 +1,51 @@
|
||||
|
||||
#ifndef BOOST_MPL_INTEGRAL_C_HPP_INCLUDED
|
||||
#define BOOST_MPL_INTEGRAL_C_HPP_INCLUDED
|
||||
|
||||
// Copyright Aleksey Gurtovoy 2000-2006
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
// See http://www.boost.org/libs/mpl for documentation.
|
||||
|
||||
// $Id$
|
||||
// $Date$
|
||||
// $Revision$
|
||||
|
||||
#include <boost/mpl/integral_c_fwd.hpp>
|
||||
#include <boost/mpl/aux_/config/ctps.hpp>
|
||||
#include <boost/mpl/aux_/config/static_constant.hpp>
|
||||
#include <boost/mpl/aux_/config/workaround.hpp>
|
||||
|
||||
#if BOOST_WORKAROUND(__HP_aCC, <= 53800)
|
||||
// the type of non-type template arguments may not depend on template arguments
|
||||
# define AUX_WRAPPER_PARAMS(N) typename T, long N
|
||||
#else
|
||||
# define AUX_WRAPPER_PARAMS(N) typename T, T N
|
||||
#endif
|
||||
|
||||
#define AUX_WRAPPER_NAME integral_c
|
||||
#define AUX_WRAPPER_VALUE_TYPE T
|
||||
#define AUX_WRAPPER_INST(value) AUX_WRAPPER_NAME< T, value >
|
||||
#include <boost/mpl/aux_/integral_wrapper.hpp>
|
||||
|
||||
|
||||
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \
|
||||
&& !BOOST_WORKAROUND(__BORLANDC__, <= 0x551)
|
||||
BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN
|
||||
// 'bool' constant doesn't have 'next'/'prior' members
|
||||
template< bool C >
|
||||
struct integral_c<bool, C>
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value = C);
|
||||
typedef integral_c_tag tag;
|
||||
typedef integral_c type;
|
||||
typedef bool value_type;
|
||||
operator bool() const { return this->value; }
|
||||
};
|
||||
BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE
|
||||
#endif
|
||||
|
||||
#endif // BOOST_MPL_INTEGRAL_C_HPP_INCLUDED
|
||||
Reference in New Issue
Block a user