text stringlengths 8 4.13M |
|---|
use hacspec_lib::*;
use hacspec_sha512::*;
#[test]
fn test_sha512() {
let msg = ByteSeq::from_public_slice(b"hello world");
let expected = "309ecc489c12d6eb4cc40f50c902f2b4d0ed77ee511a7c7a9bcd3ca86d4cd86f\
989dd35bc5ff499670da34255b45b0cfd830e81f605dcf7dc5542e93ae9cd76f";
let result = sha512(&msg);
assert_eq!(expected, result.to_hex());
}
#[test]
fn test_empty() {
let msg = ByteSeq::from_public_slice(b"");
let expected = "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce\
47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e";
let result = sha512(&msg);
assert_eq!(expected, result.to_hex());
}
|
use pyo3::class::PyMappingProtocol;
use pyo3::prelude::*;
use std::cell::RefCell;
use std::cmp;
use std::collections::HashSet;
const PUSH1: usize = 0x60;
const PUSH32: usize = 0x7f;
const STOP: usize = 0x00;
#[pyclass(subclass)]
pub struct CodeStream {
#[pyo3(get, set)]
program_counter: usize,
#[pyo3(get)]
raw_code_bytes: Vec<u8>,
#[pyo3(get)]
length_cache: usize,
invalid_positions: RefCell<HashSet<usize>>,
valid_positions: RefCell<HashSet<usize>>,
}
#[pymethods]
impl CodeStream {
#[new]
pub fn new(code_bytes: Vec<u8>) -> CodeStream {
CodeStream {
program_counter: 0,
length_cache: code_bytes.len(),
raw_code_bytes: code_bytes,
invalid_positions: RefCell::new(HashSet::new()),
valid_positions: RefCell::new(HashSet::new()),
}
}
pub fn read(&mut self, size: usize) -> &[u8] {
let old_program_counter = self.program_counter;
let target_program_counter = old_program_counter + size;
self.program_counter = target_program_counter;
&self.raw_code_bytes[old_program_counter..target_program_counter]
}
pub fn peek(&self) -> usize {
let pc = self.program_counter;
if pc < self.length_cache {
self.raw_code_bytes[pc].into()
} else {
STOP
}
}
pub fn is_valid_opcode(&self, position: usize) -> bool {
if position >= self.length_cache || self.invalid_positions.borrow().contains(&position) {
false
} else if self.valid_positions.borrow().contains(&position) {
true
} else {
// An opcode is not valid, if it is the "data" following a PUSH_
// So we look at the previous 32 bytes (PUSH32 being the largest) to see if there
// is a PUSH_ before the opcode in this position.
for disqualifier in self.potentially_disqualifying_opcode_positions(position) {
// Now that we found a PUSH_ before this position, we check if *that* PUSH is valid
if self.is_valid_opcode(disqualifier) {
// If the PUSH_ valid, then the current position is invalid
self.invalid_positions.borrow_mut().insert(position);
return false;
}
//Otherwise, keep looking for other potentially disqualifying PUSH_ codes
}
// We didn't find any valid PUSH_ opcodes in the 32 bytes before position; it's valid
self.valid_positions.borrow_mut().insert(position);
true
}
}
}
impl CodeStream {
// These methods do not need to be exposed to Python
fn potentially_disqualifying_opcode_positions(
&self,
position: usize,
) -> impl Iterator<Item = usize> + '_ {
// Look at the last 32 positions (from 1 byte back to 32 bytes back).
// Don't attempt to look at negative positions.
let deepest_lookback = cmp::min(32, position);
(1..deepest_lookback + 1)
.rev()
.filter_map(move |bytes_back| {
let earlier_position = position - bytes_back;
let opcode = self.raw_code_bytes[earlier_position].into();
if PUSH1 + (bytes_back - 1) <= opcode && opcode <= PUSH32 {
Some(earlier_position)
} else {
None
}
})
}
}
#[pyproto]
impl PyMappingProtocol for CodeStream {
fn __len__(&self) -> PyResult<usize> {
Ok(self.length_cache)
}
fn __getitem__(&self, key: usize) -> PyResult<usize> {
Ok(self.raw_code_bytes[key].into())
}
// fn __iter__(&self, py: Python) -> () {
// let iter = IntoPy::into_py(
// Py::new(py, PyMappingIter::new(self.map.iter().map(|(k, _)| k.to_owned()).collect()))?,
// py,
// );
// Ok(iter)
// }
}
|
use crate::codegen::unit::function::Func;
use llvm_sys_wrapper::{Builder, Context, LLVMBasicBlockRef, LLVMValueRef, Module, LLVM};
use std::{
collections::HashMap,
io,
path::{Path, PathBuf},
rc::{Rc, Weak},
};
use crate::{
codegen::{
codegen_binary,
comp_unit::CompilationUnit,
expr::const_expr::{const_atom, fold_constant},
mangle_v1::NameMangler,
unit::{
alloc_variable, declare_and_compile_function, declare_function, init_record,
store_value, Slot,
},
CompileError, Scope, ValueTypePair,
},
fmt::AatbeFmt,
ty::{
record::store_named_field,
size::AatbeSizeOf,
variant::{Variant, VariantType},
LLVMTyInCtx, Record, TypeContext, TypeKind, TypedefKind,
},
};
use super::{
builder::{cast, core},
unit::function::{find_func, FuncTyMap},
};
use parser::{
ast,
ast::{AtomKind, Expression, FunctionType, PrimitiveType, AST},
};
pub type InternalFunc = dyn Fn(&mut AatbeModule, &Vec<Expression>, String) -> Option<ValueTypePair>;
#[allow(dead_code)]
pub struct AatbeModule {
llvm_context: Context,
llvm_module: Module,
name: String,
scope_stack: Vec<Scope>,
typectx: TypeContext,
compile_errors: Vec<CompileError>,
record_templates: HashMap<String, AST>,
function_templates: HashMap<String, Expression>,
stdlib_path: Option<PathBuf>,
internal_functions: HashMap<String, Rc<InternalFunc>>,
compilation_units: HashMap<String, CompilationUnit>,
}
impl AatbeModule {
pub fn new(name: String, base_cu: CompilationUnit, stdlib_path: Option<PathBuf>) -> Self {
LLVM::initialize();
let llvm_context = Context::new();
let llvm_module = llvm_context.create_module(name.as_ref());
let mut internal_functions: HashMap<String, Rc<InternalFunc>> = HashMap::new();
internal_functions.insert(String::from("len"), Rc::new(AatbeModule::internal_len));
internal_functions.insert(String::from("box"), Rc::new(AatbeModule::internal_box));
let mut compilation_units = HashMap::new();
compilation_units.insert(name.clone(), base_cu);
Self {
llvm_context,
llvm_module,
name,
scope_stack: vec![],
typectx: TypeContext::new(),
compile_errors: vec![],
record_templates: HashMap::new(),
function_templates: HashMap::new(),
stdlib_path,
internal_functions,
compilation_units,
}
}
pub fn compile(&mut self) {
let base_cu = self.compilation_units.get(&self.name).unwrap();
self.scope_stack.push(Scope::with_builder_and_fdir(
Builder::new_in_context(self.llvm_context.as_ref()),
base_cu.path().clone(),
));
let main_ast = self
.compilation_units
.get(&self.name.clone())
.unwrap()
.ast()
.clone();
self.decl_pass(&main_ast);
self.codegen_pass(&main_ast);
self.exit_scope();
}
pub fn parse_import(&mut self, module: &String) -> io::Result<CompilationUnit> {
let mut path = self.fdir().with_file_name(module);
path.set_extension("aat");
if !path.exists() {
path = PathBuf::from(
self.stdlib_path
.as_ref()
.unwrap()
.join(&Path::new(format!("{}.aat", module).as_str())),
);
}
CompilationUnit::new(path)
}
pub fn decl_expr(&mut self, expr: &Expression) {
match expr {
Expression::Function { type_names, .. } if type_names.len() == 0 => {
declare_function(self, expr)
}
Expression::Function { name, .. } => {
if !self.function_templates.contains_key(name) {
self.function_templates.insert(name.clone(), expr.clone());
}
}
_ => panic!("Top level {:?} unsupported", expr),
}
}
pub fn decl_pass(&mut self, ast: &AST) {
match ast {
AST::Constant { .. } | AST::Global { .. } => {}
AST::Record(name, None, types) => {
let rec = Record::new(self, name, types);
self.typectx.push_type(name, TypeKind::RecordType(rec));
self.typectx.get_record(name).unwrap().set_body(self, types);
}
AST::Record(name, Some(type_names), ..) => {
if self.record_templates.contains_key(name) {
panic!("Record {}[{}] already exists", name, type_names.join(", "));
}
self.record_templates.insert(name.clone(), ast.clone());
}
AST::File(nodes) => nodes
.iter()
.fold(None, |_, n| Some(self.decl_pass(n)))
.unwrap(),
AST::Expr(expr) => self.decl_expr(expr),
AST::Import(module) => {
let cu = self
.parse_import(module)
.expect("Something is completely broken");
if !self.compilation_units.contains_key(cu.name()) {
self.scope_stack.push(Scope::with_builder_and_fdir(
Builder::new_in_context(self.llvm_context.as_ref()),
cu.path().clone(),
));
self.decl_pass(&cu.ast());
self.codegen_pass(&cu.ast());
self.compilation_units.insert(cu.name().clone(), cu);
self.exit_scope();
}
}
AST::Typedef {
name,
type_names: None,
variants: None,
} => {
self.typectx.push_type(
&name,
TypeKind::Typedef(TypedefKind::Opaque(
self.llvm_context_ref()
.StructTypeNamed(name.as_ref())
.as_ref(),
)),
);
}
AST::Typedef {
type_names: None, ..
} => self.gen_newtype_ctors(&ast),
_ => panic!("cannot decl {:?}", ast),
}
}
#[allow(unused_unsafe)]
pub fn gen_variants(&mut self, typedef: &AST) {
match typedef {
AST::Typedef {
name,
type_names: None,
variants: Some(variants),
} => {
let max_size = variants.iter().map(|vari| vari.size_of()).max().unwrap();
let smallest = variants.iter().map(|vari| vari.smallest()).min().unwrap();
let size = max_size / smallest;
let smallest_ty = PrimitiveType::UInt(smallest.into());
let td_struct = self.llvm_context_ref().StructTypeNamed(name.as_ref());
td_struct.set_body(
&mut vec![
smallest_ty.llvm_ty_in_ctx(self),
self.llvm_context_ref()
.ArrayType(smallest_ty.llvm_ty_in_ctx(self), size as u32),
],
false,
);
self.typectx.push_type(
name,
TypeKind::Typedef(TypedefKind::VariantType(VariantType {
type_name: name.clone(),
variants: HashMap::new(),
discriminant_type: smallest_ty.clone(),
ty: td_struct.as_ref(),
})),
);
variants
.iter()
.enumerate()
.for_each(|(i, variant)| match variant {
ast::TypeKind::Variant(variant_name, types) => {
let ty = self
.llvm_context_ref()
.StructTypeNamed(variant_name.as_ref());
let mut tys = vec![smallest_ty.llvm_ty_in_ctx(self)];
if let Some(types) = types {
tys.extend(types.iter().map(|ty| ty.llvm_ty_in_ctx(self)));
};
ty.set_body(tys.as_mut(), true);
self.typectx_ref_mut()
.push_variant(
name,
variant_name,
Variant {
parent_name: name.clone(),
name: variant_name.clone(),
types: types.clone(),
ty: ty.as_ref(),
discriminant: i as u32,
},
)
.expect(format!("Cannot find variant {}", name.clone()).as_ref());
}
_ => unimplemented!("{:?}", variant),
});
variants
.iter()
.enumerate()
.for_each(|(i, variant)| match variant {
ast::TypeKind::Variant(variant_name, _) => {
self.internal_functions.insert(
variant_name.clone(),
Rc::new(move |module, values, name| {
let values = values
.iter()
.filter_map(|value| module.codegen_expr(&value))
.collect::<Vec<_>>();
if let Some(Variant {
name, types, ty, ..
}) = module.typectx_ref().get_variant(&name)
{
let parent_ty = module
.typectx_ref()
.get_parent_for_variant(&name)
.unwrap();
let parent = module
.llvm_builder_ref()
.build_alloca(parent_ty.llvm_ty_in_ctx(module));
let discriminator =
module.llvm_builder_ref().build_bitcast(
parent,
module.llvm_context_ref().PointerType(
parent_ty
.discriminant_type
.llvm_ty_in_ctx(module),
),
);
module.llvm_builder_ref().build_store(
*const_atom(
module,
&AtomKind::Integer(
i as u64,
parent_ty.discriminant_type.clone(),
),
)
.unwrap(),
discriminator,
);
let variant = module.llvm_builder_ref().build_bitcast(
parent,
module.llvm_context_ref().PointerType(unsafe { *ty }),
);
if let Some(types) = types {
if types.len() != values.len() {
return None;
}
values.iter().enumerate().for_each(|(i, value)| {
module.llvm_builder_ref().build_store(
**value,
module
.llvm_builder_ref()
.build_struct_gep(variant, (i + 1) as u32),
);
});
}
Some(
(variant, PrimitiveType::VariantType(name.clone()))
.into(),
)
} else {
None
}
}),
);
}
_ => unimplemented!(),
});
}
_ => unreachable!(),
}
}
pub fn gen_newtype_ctors(&mut self, typedef: &AST) {
match typedef {
AST::Typedef {
name,
type_names: None,
variants: Some(variants),
} => {
if variants.len() == 1 {
match &variants[0] {
ast::TypeKind::Newtype(ty) => {
let newtystruct =
self.llvm_context_ref().StructTypeNamed(name.as_ref());
newtystruct.set_body(&mut vec![ty.llvm_ty_in_ctx(self)], false);
self.internal_functions.insert(
name.clone(),
Rc::new(|module, values, name| {
let newtystruct = module
.typectx_ref()
.get_type(&name)?
.llvm_ty_in_ctx(module);
if values.len() != 1 {
return None;
}
let val = *(module.codegen_expr(&values[0])?);
let res = module.llvm_builder_ref().build_alloca(newtystruct);
module.llvm_builder_ref().build_store(
val,
module.llvm_builder_ref().build_struct_gep(res, 0),
);
Some((res, PrimitiveType::Newtype(name.clone())).into())
}),
);
self.typectx.push_type(
&name.clone(),
TypeKind::Typedef(TypedefKind::Newtype(
newtystruct.as_ref(),
ty.clone(),
)),
);
}
ast::TypeKind::Variant(..) => self.gen_variants(typedef),
}
} else {
self.gen_variants(typedef);
}
}
_ => unreachable!(),
}
}
pub fn get_interior_pointer(&self, parts: Vec<String>) -> Option<ValueTypePair> {
match parts.as_slice() {
[field, access @ ..] => {
let agg_bind = self.get_var(&field)?;
let agg_ty = self
.typectx_ref()
.get_aggregate_from_prim(&agg_bind.var_ty())?;
Some(
self.typectx_ref()
.gep_fields(self, agg_ty, access.to_vec(), agg_bind.into())
.expect(format!("ICE get_field_named {}", field).as_str()),
)
}
[] => unreachable!(),
}
}
pub fn has_ret(&self, expr: &Expression) -> bool {
match expr {
Expression::Ret(_) => true,
Expression::Block(vals) if vals.len() > 0 => {
vals.iter().fold(false, |_, n| self.has_ret(n))
}
_ => false,
}
}
pub fn codegen_expr(&mut self, expr: &Expression) -> Option<ValueTypePair> {
match expr {
Expression::Ret(box _value) => {
let val = self.codegen_expr(_value)?;
let func_ret = self
.get_func(self.get_function().expect("Compiler borked rets"))
.expect("Must be in a function for ret statement")
.ret_ty()
.clone();
if let PrimitiveType::VariantType(ty) = val.prim() {
let parent_ty = self
.typectx_ref()
.get_parent_for_variant(ty)
.expect("ICE: Variant without parent");
if let PrimitiveType::TypeRef(name) = &func_ret {
if &parent_ty.type_name == name {
Some(core::ret(
self,
(cast::child_to_parent(self, val, parent_ty), func_ret).into(),
))
} else if &parent_ty.type_name != name && ty != name {
self.add_error(CompileError::ExpectedType {
expected_ty: func_ret.fmt(),
found_ty: val.prim().fmt(),
value: _value.fmt(),
});
None
} else {
panic!("ICE");
}
} else {
panic!("ICE");
}
} else if val.prim() != &func_ret {
self.add_error(CompileError::ExpectedType {
expected_ty: func_ret.fmt(),
found_ty: val.prim().fmt(),
value: _value.fmt(),
});
None
} else {
Some(core::ret(self, val))
}
}
Expression::RecordInit {
record,
types,
values,
} if types.len() == 0 => {
let rec = self.llvm_builder_ref().build_alloca(
self.typectx_ref()
.get_type(record)
.expect(format!("ICE could not find record {}", record).as_str())
.llvm_ty_in_ctx(self),
);
values.iter().for_each(|val| match val {
AtomKind::NamedValue { name, val } => {
let val_ref = self
.codegen_expr(val)
.expect(format!("ICE could not codegen {:?}", val).as_str());
let val_ty = val_ref.prim().fmt();
match store_named_field(
self,
rec,
record,
self.typectx_ref()
.get_record(record)
.expect(format!("ICE could not find record {}", record).as_str()),
name,
val_ref,
) {
Ok(_) => {}
Err(expected) => self.add_error(CompileError::StoreMismatch {
expected_ty: expected.fmt(),
found_ty: val_ty,
value: val.fmt(),
lval: record.clone(),
}),
};
}
_ => panic!("ICE codegen_expr {:?}", expr),
});
Some(
(
self.llvm_builder_ref().build_load(rec),
PrimitiveType::TypeRef(record.clone()),
)
.into(),
)
}
Expression::Assign { lval, value } => match value {
box Expression::RecordInit {
record,
types,
values,
} => init_record(
self,
lval,
&Expression::RecordInit {
record: record.clone(),
types: types.clone(),
values: values.to_vec(),
},
),
_ => store_value(self, lval, value),
},
Expression::Decl {
ty: PrimitiveType::NamedType { name, ty: Some(ty) },
value: _,
exterior_bind: _,
} => {
alloc_variable(self, expr);
Some(
(
self.get_var(name).expect("Compiler crapped out.").into(),
*ty.clone(),
)
.into(),
)
}
Expression::Decl {
ty: PrimitiveType::NamedType { name, ty: None },
value,
exterior_bind: _,
} => {
if value.is_none() {
self.add_error(CompileError::ExpectedValue { name: name.clone() });
return None;
}
alloc_variable(self, expr).and_then(|ty| {
Some(
(
self.get_var(name).expect("Compiler crapped out.").into(),
ty,
)
.into(),
)
})
}
Expression::Loop { .. } => self.codegen_basic_loop(expr),
Expression::If { .. } => self.codegen_if(expr),
Expression::Call { .. } => self.codegen_call(expr),
Expression::Binary(lhs, op, rhs) => match codegen_binary(self, op, lhs, rhs) {
Ok(val) => Some(val),
Err(_) => {
self.add_error(CompileError::FailedBinary {
op: op.clone(),
lhs: lhs.fmt(),
rhs: rhs.fmt(),
});
None
}
},
Expression::Function { ty, type_names, .. } if type_names.len() == 0 => match ty {
FunctionType {
ret_ty: _,
params: _,
ext: true,
} => None,
_ => declare_and_compile_function(self, expr),
},
Expression::Function { .. } => None,
Expression::Block(nodes) if nodes.len() == 0 => None,
Expression::Block(nodes) => {
self.start_scope();
let ret = nodes
.iter()
.fold(None, |_, n| Some(self.codegen_expr(n)))
.unwrap();
self.exit_scope();
ret
}
Expression::Atom(atom) => self.codegen_atom(atom),
_ => panic!(format!("ICE: codegen_expr {:?}", expr)),
}
}
pub fn codegen_pass(&mut self, ast: &AST) -> Option<LLVMValueRef> {
match ast {
AST::Constant {
ty: PrimitiveType::NamedType { name, ty: _ },
export,
value: _,
}
| AST::Global {
ty: PrimitiveType::NamedType { name, ty: _ },
export,
value: _,
} => {
fold_constant(self, ast).map(|constant| {
if !export {
self.push_in_scope(name, constant)
} else {
self.export_global(name, constant)
}
});
None
}
AST::File(nodes) => nodes
.iter()
.fold(None, |_, n| Some(self.codegen_pass(n)))
.unwrap(),
AST::Expr(expr) => self.codegen_expr(expr).map(|e| *e),
AST::Import(..) => None,
AST::Record(..) => None,
AST::Typedef { .. } => None,
_ => panic!("cannot codegen {:?}", ast),
}
}
pub fn start_scope(&mut self) {
self.scope_stack.push(Scope::new());
}
pub fn start_scope_with_name(&mut self, name: &String) {
self.scope_stack.push(Scope::with_name(name));
}
pub fn start_scope_with_function(&mut self, func: (String, FunctionType), builder: Builder) {
self.scope_stack.push(Scope::with_function(func, builder));
}
pub fn exit_scope(&mut self) {
self.scope_stack.pop();
}
pub fn get_in_scope(&self, name: &String) -> Option<&Slot> {
for scope in self.scope_stack.iter().rev() {
if let Some(sym) = scope.find_symbol(name) {
return Some(sym);
}
}
None
}
pub fn get_function(&self) -> Option<(String, FunctionType)> {
for scope in self.scope_stack.iter().rev() {
if let Some(function) = scope.function() {
return Some(function);
}
}
None
}
pub fn basic_block(&mut self, name: String) -> LLVMBasicBlockRef {
for scope in self.scope_stack.iter().rev() {
let bb = scope.bb(self, &name);
if let Some(bb) = bb {
return bb;
}
}
panic!("Compiler broke. Scope stack is corrupted.");
}
pub fn push_in_scope(&mut self, name: &String, unit: Slot) {
self.scope_stack
.last_mut()
.expect("Compiler broke. Scope stack is corrupted.")
.add_symbol(name, unit);
}
pub fn add_function(&mut self, name: &String, func: Func) {
self.scope_stack
.last_mut()
.expect("Compiler broke. Scope stack is corrupted.")
.add_function(name, func);
}
pub fn export_function(&mut self, name: &String, func: Func) {
self.scope_stack
.first_mut()
.expect("Compiler broke. Scope stack is corrupted.")
.add_function(name, func);
}
pub fn export_global(&mut self, name: &String, unit: Slot) {
self.scope_stack
.first_mut()
.expect("Compiler broke. Scope stack is corrupted.")
.add_symbol(name, unit);
}
pub fn get_func_group(&self, name: &String) -> Option<&FuncTyMap> {
for scope in self.scope_stack.iter().rev() {
if let Some(func) = scope.func_by_name(name) {
return Some(func);
}
}
None
}
pub fn get_func(&self, func: (String, FunctionType)) -> Option<&Func> {
for scope in self.scope_stack.iter().rev() {
if let Some(group) = scope.func_by_name(&func.0) {
return find_func(group, &func.1);
}
}
None
}
pub fn propagate_generic_body(
body: Box<Expression>,
type_map: HashMap<&String, PrimitiveType>,
) -> Box<Expression> {
box match body {
box Expression::Atom(atom) => Expression::Atom(match atom {
AtomKind::Cast(box atom, PrimitiveType::TypeRef(ty_ref)) => {
AtomKind::Cast(box atom, type_map[&ty_ref].clone())
}
AtomKind::Parenthesized(expr) => AtomKind::Parenthesized(
AatbeModule::propagate_generic_body(expr, type_map.clone()),
),
atom => atom,
}),
box expr => expr,
}
}
/*pub fn get_params_generic(
&mut self,
template: &String,
name: &String,
types: Vec<PrimitiveType>,
) -> Option<Vec<PrimitiveType>> {
self.get_params(name).or_else(|| {
self.propagate_types_in_function(template, types.clone())
.and_then(|ty| match self.function_templates.get(template) {
Some(Expression::Function {
name: fname,
body,
attributes,
type_names,
..
}) => {
let type_map = type_names.iter().zip(types).collect::<HashMap<_, _>>();
let function = Expression::Function {
name: fname.clone(),
ty: ty.clone(),
body: body.as_ref().map(|body| {
AatbeModule::propagate_generic_body(body.clone(), type_map)
}),
attributes: attributes.clone(),
type_names: type_names.clone(),
export: true,
};
declare_and_compile_function(self, &function);
if let FunctionType { params, .. } = ty {
Some(
params
.iter()
.map(|p| match p {
PrimitiveType::NamedType {
ty: Some(box ty), ..
} => ty.clone(),
_ => p.clone(),
})
.collect::<Vec<_>>(),
)
} else {
unreachable!();
}
}
Some(_) => unreachable!(),
None => unreachable!(),
})
})
}*/
pub fn is_extern(&self, func: (String, FunctionType)) -> bool {
let val_ref = self.get_func(func);
if let Some(func) = val_ref {
func.is_extern()
} else {
false
}
}
pub fn get_var(&self, name: &String) -> Option<&Slot> {
let val_ref = self.get_in_scope(name);
match val_ref {
Some(Slot::Variable {
mutable: _,
name: _,
ty: _,
value: _,
}) => val_ref,
Some(Slot::FunctionArgument(_arg, _)) => val_ref,
_ => None,
}
}
pub fn propagate_types_in_function(
&mut self,
name: &String,
types: Vec<PrimitiveType>,
) -> Option<FunctionType> {
if types.len() == 0 {
return None;
}
let func = format!(
"{}[{}]",
name,
types
.iter()
.map(|ty| ty.fmt())
.collect::<Vec<_>>()
.join(", ")
);
if !self.function_templates.contains_key(name) {
self.add_error(CompileError::NoGenericFunction {
function: func.clone(),
});
return None;
}
if let Some(Expression::Function {
type_names,
ty: FunctionType { ret_ty, params, .. },
..
}) = self.function_templates.get(name)
{
if type_names.len() != types.len() {
self.compile_errors
.push(CompileError::NoGenericFunction { function: func });
return None;
}
let type_map = type_names.iter().zip(types).collect::<HashMap<_, _>>();
let ret_ty = match ret_ty {
box PrimitiveType::TypeRef(ty) => {
if type_map.contains_key(ty) {
box type_map[ty].clone()
} else {
box PrimitiveType::TypeRef(ty.clone())
}
}
_ => ret_ty.clone(),
};
let params = params
.iter()
.map(|param| match param {
PrimitiveType::TypeRef(ty) => {
if type_map.contains_key(ty) {
type_map[ty].clone()
} else {
PrimitiveType::TypeRef(ty.clone())
}
}
PrimitiveType::NamedType {
name,
ty: Some(box PrimitiveType::TypeRef(ty)),
} => {
if type_map.contains_key(ty) {
PrimitiveType::NamedType {
name: name.clone(),
ty: Some(box type_map[ty].clone()),
}
} else {
PrimitiveType::NamedType {
name: name.clone(),
ty: Some(box PrimitiveType::TypeRef(ty.clone())),
}
}
}
_ => param.clone(),
})
.collect::<Vec<_>>();
let ty = FunctionType {
ext: false,
ret_ty,
params,
};
let function = Expression::Function {
name: name.clone(),
type_names: type_names.clone(),
ty: ty.clone(),
body: None,
attributes: vec![],
export: false,
};
self.add_function(
&name,
Func::new(
ty.clone(),
name.clone(),
self.llvm_module_ref().get_or_add_function(
function.mangle(self).as_ref(),
ty.llvm_ty_in_ctx(self),
),
),
);
Some(ty)
} else {
None
}
}
pub fn propagate_types_in_record(&mut self, name: &String, types: Vec<PrimitiveType>) {
let rec = format!(
"{}[{}]",
name,
types
.iter()
.map(|ty| ty.fmt())
.collect::<Vec<_>>()
.join(", ")
);
if !self.record_templates.contains_key(name) {
self.add_error(CompileError::NoGenericRecord { rec: rec.clone() })
}
if let Some(AST::Record(_, Some(type_names), fields)) = self.record_templates.get(name) {
if type_names.len() != types.len() {
self.compile_errors
.push(CompileError::NoGenericRecord { rec: rec.clone() })
}
let type_map = type_names.iter().zip(types).collect::<HashMap<_, _>>();
let fields = fields
.iter()
.map(|field| {
if let PrimitiveType::NamedType { name, ty } = field {
if let Some(box PrimitiveType::TypeRef(ty_name)) = ty {
if type_map.contains_key(ty_name) {
PrimitiveType::NamedType {
name: name.clone(),
ty: Some(box type_map[ty_name].clone()),
}
} else {
*ty.as_ref().unwrap().clone()
}
} else {
*ty.as_ref().unwrap().clone()
}
} else {
panic!("ICE propagate_type {:?}", field)
}
})
.collect::<Vec<_>>();
self.typectx
.push_type(&rec, TypeKind::RecordType(Record::new(self, &rec, &fields)));
self.typectx
.get_record(&rec)
.unwrap()
.set_body(self, &fields);
}
}
pub fn fdir(&self) -> PathBuf {
for scope in self.scope_stack.iter().rev() {
if let Some(fdir) = scope.fdir() {
return fdir.clone();
}
}
unreachable!();
}
pub fn llvm_builder_ref(&self) -> &Builder {
for scope in self.scope_stack.iter().rev() {
if let Some(builder) = scope.builder() {
return builder;
}
}
unreachable!();
}
pub fn llvm_module_ref(&self) -> &Module {
&self.llvm_module
}
pub fn llvm_context_ref(&self) -> &Context {
&self.llvm_context
}
pub fn typectx_ref(&self) -> &TypeContext {
&self.typectx
}
pub fn typectx_ref_mut(&mut self) -> &mut TypeContext {
&mut self.typectx
}
pub fn add_error(&mut self, error: CompileError) {
self.compile_errors.push(error);
}
pub fn errors(&self) -> &Vec<CompileError> {
&self.compile_errors
}
pub fn has_internal(&self, key: &String) -> bool {
self.internal_functions.contains_key(key)
}
pub fn get_internal(&self, key: &String) -> Weak<InternalFunc> {
Rc::downgrade(&self.internal_functions[key])
}
}
|
//! All code responsible for validating sources.
use apt_sources_lists::{SourceEntry, SourceError, SourcesList};
use distinst_chroot::Command;
use std::{fs, io, path::Path};
use ubuntu_version::Codename;
#[derive(Debug, Error)]
pub enum SourcesError {
#[error(display = "/etc/apt/sources.list was missing, and we failed to create it: {}", _0)]
ListCreation(io::Error),
#[error(display = "failed to read sources: {}", _0)]
ListRead(SourceError),
#[error(display = "failed to overwrite a source list: {}", _0)]
ListWrite(io::Error),
#[error(display = "failed to add missing PPA from Launchpad: {}", _0)]
PpaAdd(io::Error),
}
impl From<SourceError> for SourcesError {
fn from(why: SourceError) -> Self {
SourcesError::ListRead(why)
}
}
const MAIN_SOURCES: &str = "/etc/apt/sources.list";
const POP_PPAS: &[&str] = &["system76/pop"];
pub fn repair(codename: Codename) -> Result<(), SourcesError> {
let current_release = <&'static str>::from(codename);
if !Path::new(MAIN_SOURCES).exists() {
info!("/etc/apt/sources.list did not exist: creating a new one");
return create_new_sources_list(current_release).map_err(SourcesError::ListCreation);
}
info!("ensuring that the proprietary pop repo is added");
let mut sources_list = SourcesList::scan().map_err(SourcesError::ListRead)?;
insert_entry(
&mut sources_list,
MAIN_SOURCES,
"http://apt.pop-os.org/proprietary",
current_release,
&["main"],
)?;
sources_list.write_sync().map_err(SourcesError::ListWrite)?;
for ppa in POP_PPAS {
let url = ["http://ppa.launchpad.net/", *ppa, "/ubuntu"].concat();
if sources_list.iter().any(|file| file.contains_entry(&url).is_some()) {
info!("PPA {} found: not adding", *ppa);
} else {
info!("adding PPA: {}", *ppa);
ppa_add(*ppa)?;
}
}
Ok(())
}
fn ppa_add(ppa: &str) -> Result<(), SourcesError> {
Command::new("add-apt-repository")
.arg(format!("ppa:{}", ppa))
.arg("-ny")
.run()
.map_err(SourcesError::PpaAdd)
}
fn insert_entry<P: AsRef<Path>>(
sources_list: &mut SourcesList,
preferred: P,
url: &str,
suite: &str,
components: &[&str],
) -> Result<(), SourcesError> {
sources_list.insert_entry(
preferred,
SourceEntry {
source: false,
options: None,
url: url.to_owned(),
suite: suite.to_owned(),
components: components.iter().cloned().map(String::from).collect(),
},
)?;
Ok(())
}
fn create_new_sources_list(release: &str) -> io::Result<()> {
fs::write(MAIN_SOURCES, format!(
"deb http://us.archive.ubuntu.com/ubuntu/ {0} restricted multiverse universe main\n\
deb-src http://us.archive.ubuntu.com/ubuntu/ {0} restricted multiverse universe main\n\
deb http://us.archive.ubuntu.com/ubuntu/ {0}-updates restricted multiverse universe main\n\
deb-src http://us.archive.ubuntu.com/ubuntu/ {0}-updates restricted multiverse universe main\n\
deb http://us.archive.ubuntu.com/ubuntu/ {0}-security restricted multiverse universe main\n\
deb-src http://us.archive.ubuntu.com/ubuntu/ {0}-security restricted multiverse universe main\n\
deb http://us.archive.ubuntu.com/ubuntu/ {0}-backports restricted multiverse universe main\n\
deb-src http://us.archive.ubuntu.com/ubuntu/ {0}-backports restricted multiverse universe main\n\
deb http://apt.pop-os.org/proprietary {0} main\n",
release
))?;
// TODO: Ensure that the GPG keys are added for the Ubuntu archives.
Ok(())
}
|
// SPDX-License-Identifier: Apache-2.0
#[cfg(feature = "backend-kvm")]
pub mod kvm;
#[cfg(feature = "backend-sgx")]
pub mod sgx;
mod probe;
use crate::binary::Component;
use std::sync::Arc;
use anyhow::Result;
use sallyport::Block;
pub trait Backend {
/// The name of the backend
fn name(&self) -> &'static str;
/// The builtin shim
fn shim(&self) -> &'static [u8];
/// Whether or not the platform has support for this keep type
fn have(&self) -> bool {
!self.data().iter().fold(false, |e, d| e | !d.pass)
}
/// The tests that show platform support for the backend
fn data(&self) -> Vec<Datum>;
/// Create a keep instance on this backend
fn build(&self, shim: Component, code: Component) -> Result<Arc<dyn Keep>>;
}
pub struct Datum {
/// The name of this datum.
pub name: String,
/// Whether the datum indicates support for the platform or not.
pub pass: bool,
/// Short additional information to display to the user.
pub info: Option<String>,
/// Longer explanatory message on how to resolve problems.
pub mesg: Option<String>,
}
pub trait Keep {
/// Creates a new thread in the keep.
fn spawn(self: Arc<Self>) -> Result<Option<Box<dyn Thread>>>;
}
pub trait Thread {
/// Enters the keep.
fn enter(&mut self) -> Result<Command>;
}
pub enum Command<'a> {
#[allow(dead_code)]
SysCall(&'a mut Block),
#[allow(dead_code)]
Continue,
}
|
use gtk::*;
use gtk::ImageExt;
use gdk_pixbuf::Pixbuf;
use gdk_pixbuf::Colorspace;
use image::Image as MyImage;
use image::image::{GenericImageView};
pub struct ImageContainer {
pub image_widget: Image
}
impl ImageContainer {
pub fn new() -> Self {
let image_widget = Image::new();
Self {
image_widget
}
}
}
pub fn render_image(image_widget: &Image, image: &MyImage) {
let dynamic_image = image.get_dynamic_image();
let pixels = dynamic_image.raw_pixels();
let (width, height) = dynamic_image.dimensions();
let pixbuf = Pixbuf::new_from_vec(
pixels,
Colorspace::Rgb,
false,
8,
width as i32,
height as i32,
3*width as i32);
image_widget.set_halign(Align::Start);
image_widget.set_from_pixbuf(&pixbuf);
}
|
use std::marker::PhantomData;
use crate::{
AnyRc, ArcBin, BinBuilder, BinFactory, BooToOwned, BuilderCfg, DefaultBinBuilder, SBin,
};
/// Default implementation used to create `SBin`. See `BinFactory` for documentation.
///
/// ```rust
/// use abin::{NewSBin, SBin, BinFactory, AnyBin};
/// let bin : SBin = NewSBin::from_static("Hello, I'm a binary!".as_bytes());
/// assert_eq!("Hello, I'm a binary!".as_bytes(), bin.as_slice());
/// ```
pub struct NewSBin {
_phantom: PhantomData<()>,
}
impl NewSBin {
/// Constructs a builder that can be used to create `SBin`.
pub fn builder<'a>() -> impl BinBuilder<'a, T = SBin> {
DefaultBinBuilder::<NewSBin, BinBuilderCfg>::new()
}
}
impl BooToOwned<[u8], SBin> for NewSBin {
fn convert_to_owned(borrowed: &[u8]) -> SBin {
Self::copy_from_slice(borrowed)
}
}
struct BinBuilderCfg;
impl BuilderCfg<SBin> for BinBuilderCfg {
fn convert_from_sbin_to_t(sbin: SBin) -> SBin {
sbin
}
fn vec_excess_capacity() -> usize {
ArcBin::overhead_bytes()
}
}
|
use std::vec::Vec;
use rand::Rng;
use rand::thread_rng;
// W I P //
fn quick_sort(array: &Vec<i64>, low: usize, high: usize){
/*
*
*/
if low < high {
let pivot = partition(&array, low, high);
quick_sort(&array, low, pivot-1);
quick_sort(&array, pivot+1, high);
}
fn partition(array: &Vec<i64>, low: usize, high: usize) -> usize {
/*
*
*/
let pivot = low-1;
for j in low..high-1 {
if array[j] <= array[high] {
pivot += 1;
// swap values
let tmp = array[pivot];
array[pivot] = array[j];
array[j] = tmp;
}
}
// swap values
let tmp = array[pivot+1];
array[pivot+1] = array[high];
array[high] = tmp;
return pivot;
}
}
fn main() {
let SIZE: usize = 2;
// create random number generator
let mut rng = thread_rng();
// create vector of random number
let mut data: Vec<i64> = (0..SIZE).map(|_| {
rng.gen_range(0, SIZE as i64)
}).collect();
// apply sorting algorithm
quick_sort(&data, 1, SIZE);
println!("{:?}", data);
}
|
mod common;
use std::path::PathBuf;
use common::{testenv, TestEnv, EXAMPLE_SUN, EXAMPLE_TIME};
use predicates::prelude::*;
use rstest::rstest;
const EXAMPLE_TIME_INFO: &str = r#"
Size: 88723B
Resolution: 512x512px
Schedule type: time
Number of images: 2
Number of frames: 2
Schedule:
Frame Image Time
1 1 00:00:00
2 0 12:00:00
Appearance:
Light: 0
Dark: 1
"#;
const EXAMPLE_SUN_INFO: &str = r#"
Size: 91566B
Resolution: 512x512px
Schedule type: solar
Number of images: 2
Number of frames: 2
Schedule:
Frame Image Azimuth Altitude
1 0 169.0 31.0
2 1 346.0 -45.0
Appearance:
Light: 0
Dark: 1
"#;
#[rstest]
#[case(EXAMPLE_TIME.to_path_buf(), EXAMPLE_TIME_INFO)]
#[case(EXAMPLE_SUN.to_path_buf(), EXAMPLE_SUN_INFO)]
fn test_info(testenv: TestEnv, #[case] wall_path: PathBuf, #[case] expected_output: &str) {
testenv
.run(&["info", wall_path.to_str().unwrap()])
.success()
.stdout(predicate::str::ends_with(expected_output));
}
|
extern crate dotenv;
use crate::graphql::Context;
use chrono::*;
use crate::models::character::Character;
use crate::models::movie::Movie;
use juniper::FieldError;
#[juniper::graphql_object(description = "A Movie", name = "Movie", Context = Context)]
impl Movie {
fn id(&self) -> i32 {
self.id
}
fn name(&self) -> String {
self.name.to_string()
}
fn released_at(&self) -> DateTime<Utc> {
DateTime::<Utc>::from_utc(self.released_at, Utc)
}
fn created_at(&self) -> DateTime<Utc> {
DateTime::<Utc>::from_utc(self.created_at, Utc)
}
fn updated_at(&self) -> DateTime<Utc> {
DateTime::<Utc>::from_utc(self.updated_at, Utc)
}
fn deleted(&self) -> bool {
self.deleted
}
async fn characters(&self, context: &Context) -> Result<Vec<Character>, FieldError> {
let character_ids = context
.character_ids_data_loader_by_movie_id
.load(self.id)
.await;
match character_ids {
Ok(characters_ids) => match context
.character_data_loader_by_id
.load_many(characters_ids)
.await
{
Ok(characters_result) => Ok(characters_result.into_iter().flatten().collect()),
Err(_) => Ok(Vec::new()),
},
Err(_) => Ok(Vec::new()),
}
}
}
|
use std::sync::{Arc, Weak};
use tinyroute::{Agent, ToAddress, Message};
// -----------------------------------------------------------------------------
// - Entity -
// -----------------------------------------------------------------------------
pub struct Entity<T: Send + 'static> {
inner: Weak<T>,
}
impl<T: Send + 'static> Entity<T> {
pub fn access(&self) -> Option<impl AsRef<T>> {
Weak::upgrade(&self.inner)
}
pub fn new(val: &Arc<T>) -> Self {
Self {
inner: Arc::downgrade(val)
}
}
}
// -----------------------------------------------------------------------------
// - Store -
// -----------------------------------------------------------------------------
pub trait Store {
type Data: Send + 'static;
fn create_entity(&self) -> Entity<Self::Data>;
}
// -----------------------------------------------------------------------------
// - Read only store -
// -----------------------------------------------------------------------------
pub struct Storage<T> {
inner: Arc<T>,
}
impl<T: Send + Sync + 'static> Storage<T> {
pub fn new(val: T) -> Self {
Self {
inner: Arc::new(val),
}
}
pub async fn into_service<A: ToAddress>(self, mut agent: Agent<(), A>) {
loop {
if let Ok(msg) = agent.recv().await {
match msg {
Message::Value((), sender) => log::info!("Message sent to a store from: {}", sender.to_string()),
Message::Fetch(req) => match req.reply_async(self.create_entity()).await {
Ok(()) => {}
Err(e) => log::error!("Failed to reply to fetch. Reason: {}", e),
}
Message::Shutdown => break,
Message::RemoteMessage { .. }
| Message::AgentRemoved(_) => {}
}
}
}
}
}
impl<T: Send + Sync + 'static> Store for Storage<T> {
type Data = T;
fn create_entity(&self) -> Entity<Self::Data> {
Entity { inner: Arc::downgrade(&self.inner) }
}
}
|
use std::fmt;
use std::io::{Read, Result};
use num::FromPrimitive;
use byteorder::{BigEndian, ReadBytesExt};
use io;
enum_from_primitive! {
#[derive(PartialEq)]
pub enum Type {
I8 = 0x0,
I16 = 0x1,
I32 = 0x2,
I64 = 0x3,
U8 = 0x4,
U16 = 0x5,
U32 = 0x6,
U64 = 0x7,
F32 = 0x8,
F64 = 0x9,
Ptr = 0xA,
Void = 0xB,
}
}
pub type VariableIndex = u16;
pub type ConstantTableIndex = u16;
enum_from_primitive! {
#[derive(Debug, PartialEq)]
pub enum Opcode {
Nop = 0x00,
Pop = 0x01,
Dup = 0x02,
Cst = 0x03,
Load = 0x04,
Store = 0x05,
Add = 0x06,
Sub = 0x07,
Mul = 0x08,
Div = 0x09,
Ret = 0x0A,
Print = 0x0B,
}
}
pub enum Instruction {
Nop,
Pop,
Dup,
Cst(ConstantTableIndex),
Load(VariableIndex),
Store(VariableIndex),
Add(Type),
Sub(Type),
Mul(Type),
Div(Type),
Ret(u8), // u8: The number of elements on the stack that are returned.
Print(Type),
}
enum_from_primitive! {
#[derive(Debug, PartialEq)]
pub enum ConstantTag {
I32 = 0x00,
I64 = 0x01,
U32 = 0x02,
U64 = 0x03,
F32 = 0x04,
F64 = 0x05,
Str = 0x06,
}
}
pub enum Constant {
I32(i32),
I64(i64),
U32(u32),
U64(u64),
F32(f32),
F64(f64),
Str(String),
}
impl Type {
pub fn from_read(read: &mut Read) -> Result<Type> {
let value = try!(read.read_u8());
match Type::from_u8(value) {
Some(t) => Ok(t),
None => panic!("Type tag not {} known.", value),
}
}
}
impl Instruction {
pub fn from_read(read: &mut Read) -> Result<Instruction> {
let opcode = try!(read.read_u8());
let opcode = match Opcode::from_u8(opcode) {
Some(opcode) => opcode,
None => panic!("Invalid opcode: {}", opcode),
};
let instruction = match opcode {
Opcode::Nop => Instruction::Nop,
Opcode::Pop => Instruction::Pop,
Opcode::Dup => Instruction::Dup,
Opcode::Cst => {
let index = try!(read.read_u16::<BigEndian>()) as ConstantTableIndex;
Instruction::Cst(index)
},
Opcode::Load => {
let index = try!(read.read_u16::<BigEndian>()) as VariableIndex;
Instruction::Load(index)
},
Opcode::Store => {
let index = try!(read.read_u16::<BigEndian>()) as VariableIndex;
Instruction::Store(index)
},
Opcode::Add => {
let t = try!(Type::from_read(read));
Instruction::Add(t)
},
Opcode::Sub => {
let t = try!(Type::from_read(read));
Instruction::Sub(t)
},
Opcode::Mul => {
let t = try!(Type::from_read(read));
Instruction::Mul(t)
},
Opcode::Div => {
let t = try!(Type::from_read(read));
Instruction::Div(t)
},
Opcode::Ret => {
let count = try!(read.read_u8());
Instruction::Ret(count)
},
Opcode::Print => {
let t = try!(Type::from_read(read));
Instruction::Print(t)
},
};
Ok(instruction)
}
}
impl Constant {
pub fn from_read(read: &mut Read) -> Result<Constant> {
let constant_tag = try!(read.read_u8());
let constant_tag: ConstantTag = match ConstantTag::from_u8(constant_tag) {
Some(tag) => tag,
None => panic!("Invalid constant tag: {}", constant_tag),
};
match constant_tag {
ConstantTag::I32 => {
let value = try!(read.read_i32::<BigEndian>());
Ok(Constant::I32(value))
},
ConstantTag::I64 => {
let value = try!(read.read_i64::<BigEndian>());
Ok(Constant::I64(value))
},
ConstantTag::U32 => {
let value = try!(read.read_u32::<BigEndian>());
Ok(Constant::U32(value))
},
ConstantTag::U64 => {
let value = try!(read.read_u64::<BigEndian>());
Ok(Constant::U64(value))
},
ConstantTag::F32 => {
let value = try!(read.read_f32::<BigEndian>());
Ok(Constant::F32(value))
},
ConstantTag::F64 => {
let value = try!(read.read_f64::<BigEndian>());
Ok(Constant::F64(value))
},
ConstantTag::Str => {
let string = try!(io::read_string(read));
Ok(Constant::Str(string))
},
}
}
}
impl fmt::Debug for Type {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
Type::I8 => write!(f, "i8"),
Type::I16 => write!(f, "i16"),
Type::I32 => write!(f, "i32"),
Type::I64 => write!(f, "i64"),
Type::U8 => write!(f, "u8"),
Type::U16 => write!(f, "u16"),
Type::U32 => write!(f, "u32"),
Type::U64 => write!(f, "u64"),
Type::F32 => write!(f, "f32"),
Type::F64 => write!(f, "f64"),
Type::Ptr => write!(f, "ptr"),
Type::Void => write!(f, "void"),
}
}
}
impl fmt::Debug for Instruction {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
Instruction::Nop => write!(f, "nop"),
Instruction::Pop => write!(f, "pop"),
Instruction::Dup => write!(f, "dup"),
Instruction::Cst(ref index) => write!(f, "cst #{:?}", index),
Instruction::Load(ref var) => write!(f, "load ${:?}", var),
Instruction::Store(ref var) => write!(f, "store ${:?}", var),
Instruction::Add(ref t) => write!(f, "add[{:?}]", t),
Instruction::Sub(ref t) => write!(f, "sub[{:?}]", t),
Instruction::Mul(ref t) => write!(f, "mul[{:?}]", t),
Instruction::Div(ref t) => write!(f, "div[{:?}]", t),
Instruction::Ret(ref count) => write!(f, "ret({:?})", count),
Instruction::Print(ref t) => write!(f, "print[{:?}]", t),
}
}
}
impl fmt::Debug for Constant {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
Constant::I32(ref num) => write!(f, "i32: {}", num),
Constant::I64(ref num) => write!(f, "i64: {}", num),
Constant::U32(ref num) => write!(f, "u32: {}", num),
Constant::U64(ref num) => write!(f, "u64: {}", num),
Constant::F32(ref num) => write!(f, "f32: {}", num),
Constant::F64(ref num) => write!(f, "f64: {}", num),
Constant::Str(ref val) => write!(f, "str: '{}'", val),
}
}
}
|
#![allow(unused)]
mod chunked_array_queue;
use crate::FifoWindow;
use alga::general::AbstractMonoid;
use alga::general::Operator;
use std::collections::VecDeque;
use std::fmt::Debug;
use std::marker::PhantomData;
#[derive(Debug)]
pub struct DABA<T, O>
where
T: Debug + AbstractMonoid<O> + Clone,
O: Debug + Operator,
{
// ith oldest value in FIFO order stored at vi = vals[i]
vals: VecDeque<T>,
aggs: VecDeque<T>,
// 0 ≤ l ≤ r ≤ a ≤ b ≤ aggs.len()
l: usize, // Left, ∀p ∈ l...r−1 : aggs[p] = vals[p] ⊕ ... ⊕ vals[r−1]
r: usize, // Right, ∀p ∈ r...a−1 : aggs[p] = vals[R] ⊕ ... ⊕ vals[p]
a: usize, // Accum, ∀p ∈ a...b−1 : aggs[p] = vals[p] ⊕ ... ⊕ vals[b−1]
b: usize, // Back, ∀p ∈ b...e−1 : aggs[p] = vals[B] ⊕ ... ⊕ vals[p]
op: PhantomData<O>,
}
impl<Value, BinOp> FifoWindow<Value, BinOp> for DABA<Value, BinOp>
where
Value: Debug + AbstractMonoid<BinOp> + Clone,
BinOp: Debug + Operator,
{
fn new() -> DABA<Value, BinOp> {
DABA {
vals: VecDeque::new(),
aggs: VecDeque::new(),
l: 0,
r: 0,
a: 0,
b: 0,
op: PhantomData,
}
}
fn push(&mut self, v: Value) {
self.aggs.push_back(self.agg_b().operate(&v));
self.vals.push_back(v);
self.fixup();
}
fn pop(&mut self) {
if let Some(_) = self.vals.pop_front() {
self.aggs.pop_front();
self.l -= 1;
self.r -= 1;
self.a -= 1;
self.b -= 1;
self.fixup();
}
}
fn query(&self) -> Value {
self.agg_f().operate(&self.agg_b())
}
}
impl<T, O> DABA<T, O>
where
T: Debug + AbstractMonoid<O> + Clone,
O: Debug + Operator,
{
#[inline(always)]
fn agg_f(&self) -> T {
if self.aggs.is_empty() {
T::identity()
} else {
self.aggs.front().unwrap().clone()
}
}
#[inline(always)]
fn agg_b(&self) -> T {
if self.b == self.aggs.len() {
T::identity()
} else {
self.aggs.back().unwrap().clone()
}
}
#[inline(always)]
fn agg_l(&self) -> T {
if self.l == self.r {
T::identity()
} else {
self.aggs[self.l].clone()
}
}
#[inline(always)]
fn agg_r(&self) -> T {
if self.r == self.a {
T::identity()
} else {
self.aggs[self.a - 1].clone()
}
}
#[inline(always)]
fn agg_a(&self) -> T {
if self.a == self.b {
T::identity()
} else {
self.aggs[self.a].clone()
}
}
fn fixup(&mut self) {
if self.b == 0 {
self.singleton()
} else {
if self.l == self.b {
self.flip()
}
if self.l == self.r {
self.shift()
} else {
self.shrink()
}
}
}
// If F == B, that means the front list lF is empty. As Section 4.4 will show,
// that can only happen if the back list lB has exactly one element. On a
// singleton list, there is no difference between aggregating to the left or
// right. Therefore, DABA can simply move pointers around to turn lB into lF
// without having to modify aggs.
#[inline(always)]
fn singleton(&mut self) {
self.l = self.aggs.len();
self.r = self.l;
self.a = self.l;
self.b = self.l;
}
// If F != B but L == B, that means that the three sublists lL, lR, and lA of lF
// are all empty. In that case, the entire lF is aggregated to the left •− and
// lB is aggregated to the right −•. So DABA can simply move pointers around to
// turn lF and lB into lL and lR , which are aggregated in the same directions.
#[inline(always)]
fn flip(&mut self) {
self.l = 0;
self.a = self.aggs.len();
self.b = self.a;
}
// If L != B but L == R, that means that lL and lR are empty but lA is non-empty.
// That means that all of lL is aggregated to the left •−. In other words, the
// boundary of lA makes no difference for the aggregation, and DABA can increment
// L, R, and A without having to modify aggs.
#[inline(always)]
fn shift(&mut self) {
self.a += 1;
self.r += 1;
self.l += 1;
}
// If L != R, that means that lL is non-empty. As Section 4.4 will show, lL and lR
// always have the same length, so lR is non-empty too. DABA shrinks both lL and lR
// by one element each. This is the only case that requires modifying aggs. DABA
// shrinks lL by incrementing L, thus moving the first element of lL to the front
// portion of lL ; the new aggs entry for that element is ΣL⊕ ⊕ ΣR⊕ ⊕ ΣA⊕. DABA
// shrinks lR by decrementing A, thus moving the last element of lR to lA; the new
// aggs entry for that element is vals[A−1] ⊕ ΣA⊕ .
#[inline(always)]
fn shrink(&mut self) {
self.aggs[self.l] = self.agg_l().operate(&self.agg_r()).operate(&self.agg_a());
self.l += 1;
self.aggs[self.a - 1] = self.vals[self.a - 1].operate(&self.agg_a());
self.a -= 1;
}
}
|
extern crate openssl;
use openssl::rsa::RSA;
use openssl::pkey::PKey;
pub trait CryptoService {
fn pubkey_pem(&self) -> Vec<u8>;
fn privkey(&self) -> Vec<u8>;
fn encrypt(&self);
fn decrypt(&self);
}
struct PKeyServiceImpl{
pkey: PKey,
}
impl PKeyService {
fn new() -> PKeyServiceImpl {
let rsa = Rsa::generate(2048).unwrap();
let pkey = PKey::from_rsa(rsa).unwrap();
PKeyServiceImpl{pkey: pkey}
}
}
impl PKeyService for PKeyServiceImpl {
fn pubkey_pem(&self) -> Vec<u8> {
let pub_key = self.pkey.public_key_to_pem().unwrap();
str::from_utf8(pub_key.as_slice()).unwrap()
}
}
fn get_keys() {
let rsa = Rsa::generate(2048).unwrap();
let pkey = PKey::from_rsa(rsa).unwrap();
pkey
} |
use hydroflow::compiled::pull::HalfMultisetJoinState;
use hydroflow::hydroflow_syntax;
use hydroflow::util::cli::{ConnectedSink, ConnectedSource};
use hydroflow::util::{deserialize_from_bytes, serialize_to_bytes};
use serde::{Deserialize, Serialize};
use tokio::net::TcpListener;
mod util;
#[derive(Clone, Serialize, Deserialize)]
struct PeerMessage {
msg: ChatMessage,
node_id: u32,
client_id: usize,
msg_id: usize,
}
#[derive(Clone, Serialize, Deserialize)]
enum FromClient {
Name(String),
Message { id: usize, text: String },
}
#[derive(Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
struct ChatMessage {
name: String,
text: String,
}
#[hydroflow::main]
async fn main() {
let mut ports = hydroflow::util::cli::init().await;
let from_peer = ports
.port("from_peer")
.connect::<hydroflow::util::cli::ConnectedDirect>()
.await
.into_source();
let to_peer = ports
.port("to_peer")
.connect::<hydroflow::util::cli::ConnectedDemux<hydroflow::util::cli::ConnectedDirect>>()
.await
.into_sink();
let number_of_nodes: u32 = std::env::args().nth(1).unwrap().parse().unwrap();
let self_node_id: u32 = std::env::args().nth(2).unwrap().parse().unwrap();
let port: u16 = std::env::args().nth(3).unwrap().parse().unwrap();
let ws_port = TcpListener::bind(("0.0.0.0", port)).await.unwrap();
println!("listening!");
let (clients_connect, clients_disconnect, from_client, to_client) =
util::ws_server(ws_port).await;
let df = hydroflow_syntax! {
all_peers = source_iter((0..number_of_nodes).filter(move |&i| i != self_node_id)) -> persist();
// networking
from_peer = source_stream(from_peer) -> map(|b| deserialize_from_bytes::<PeerMessage>(b.unwrap()).unwrap());
to_peer = map(|(peer, v): (u32, PeerMessage)| (peer, serialize_to_bytes(v))) -> dest_sink(to_peer);
from_client = source_stream(from_client) -> map(|(id, json)| (id, serde_json::from_str::<FromClient>(&json).unwrap())) -> tee();
to_client = map(|(id, data)| (id, serde_json::to_string(&data).unwrap())) -> dest_sink(to_client);
clients_connect = source_stream(clients_connect) -> tee();
clients_disconnect = source_stream(clients_disconnect);
// helpers
peer_broadcast = cross_join::<'tick, 'tick, HalfMultisetJoinState>() -> to_peer;
all_peers -> [0] peer_broadcast;
to_peers = [1] peer_broadcast;
names = from_client ->
filter_map(|(client, msg)| if let FromClient::Name(name) = msg { Some((client, name)) } else { None });
messages = from_client ->
filter_map(|(client, msg)| if let FromClient::Message { id, text } = msg { Some((client, (id, text))) } else { None });
clients_connect -> persist() -> [pos] active_clients;
clients_disconnect -> persist() -> [neg] active_clients;
active_clients = difference() -> null();
// logic
// echo server
// messages -> map(|(client, (_, text))| (client, ChatMessage {
// name: "server".to_string(),
// text,
// })) -> to_client;
// replicated chat
messages -> [0] local_messages;
names -> persist() -> [1] local_messages;
local_messages = join::<'tick, 'tick, HalfMultisetJoinState>() -> tee();
local_messages -> map(|(client_id, ((msg_id, text), name))| (ChatMessage {
name,
text
}, self_node_id, client_id, msg_id)) -> all_messages;
local_messages -> map(|(client_id, ((msg_id, text), name))| PeerMessage {
msg: ChatMessage {
name,
text
},
node_id: self_node_id,
client_id,
msg_id,
}) -> to_peers;
from_peer -> map(|p| (p.msg, p.node_id, p.client_id, p.msg_id)) -> all_messages;
all_messages = union() /* -> persist() -> (PATCH 2) */ -> unique::<'tick>() -> map(|t| t.0);
broadcast_clients = cross_join::<'static /*'tick (PATCH 1) */, 'static /*'tick, HalfMultisetJoinState (PATCH 2) */>() -> multiset_delta() -> to_client;
// active_clients -> [0] broadcast_clients; (PATCH 1)
clients_connect -> [0] broadcast_clients;
all_messages -> [1] broadcast_clients;
};
hydroflow::util::cli::launch_flow(df).await;
}
|
use epd2in9::{DEFAULT_BACKGROUND_COLOR, HEIGHT, WIDTH};
/// Full size buffer for use with the 2in9 EPD
///
/// Can also be manuall constructed:
/// `buffer: [DEFAULT_BACKGROUND_COLOR.get_byte_value(); WIDTH / 8 * HEIGHT]`
pub struct Buffer2in9 {
pub buffer: [u8; WIDTH as usize * HEIGHT as usize / 8],
}
impl Default for Buffer2in9 {
fn default() -> Self {
Buffer2in9 {
buffer: [DEFAULT_BACKGROUND_COLOR.get_byte_value();
WIDTH as usize * HEIGHT as usize / 8],
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use graphics::Display;
// test buffer length
#[test]
fn graphics_size() {
let mut buffer = Buffer2in9::default();
let display = Display::new(WIDTH, HEIGHT, &mut buffer.buffer);
assert_eq!(display.buffer().len(), 4736);
}
// test default background color on all bytes
#[test]
fn graphics_default() {
let mut buffer = Buffer2in9::default();
let display = Display::new(WIDTH, HEIGHT, &mut buffer.buffer);
for &byte in display.buffer() {
assert_eq!(byte, DEFAULT_BACKGROUND_COLOR.get_byte_value());
}
}
}
|
/*
* Datadog API V1 Collection
*
* Collection of all Datadog Public endpoints.
*
* The version of the OpenAPI document: 1.0
* Contact: support@datadoghq.com
* Generated by: https://openapi-generator.tech
*/
/// SyntheticsPlayingTab : Navigate between different tabs for your browser test.
/// Navigate between different tabs for your browser test.
#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub enum SyntheticsPlayingTab {
#[serde(rename = "-1")]
MAIN_TAB,
#[serde(rename = "0")]
NEW_TAB,
#[serde(rename = "1")]
TAB_1,
#[serde(rename = "2")]
TAB_2,
#[serde(rename = "3")]
TAB_3,
}
impl ToString for SyntheticsPlayingTab {
fn to_string(&self) -> String {
match self {
Self::MAIN_TAB => String::from("-1"),
Self::NEW_TAB => String::from("0"),
Self::TAB_1 => String::from("1"),
Self::TAB_2 => String::from("2"),
Self::TAB_3 => String::from("3"),
}
}
}
|
extern crate ares;
#[macro_use]
mod util;
#[test]
fn eval() {
eval_ok!("(eval (list + 1 2 3))", 6);
}
#[test]
fn apply() {
eval_ok!("(apply + (list 1 2 3))", 6);
}
|
use super::{Error, Result, Write};
use core::ptr::null_mut;
use crate::sync::{Mutex, Once};
use win32::{
kernel32::{FlushFileBuffers, GetStdHandle, WriteFile},
HANDLE, STD_OUTPUT_HANDLE,
};
pub struct Stdout
{
handle: Mutex<HANDLE>,
}
unsafe impl Send for Stdout {}
unsafe impl Sync for Stdout {}
impl Stdout
{
fn new() -> Self
{
Self {
handle: Mutex::new(unsafe { GetStdHandle(STD_OUTPUT_HANDLE) }),
}
}
}
impl Write for &Stdout
{
fn write(&mut self, buf: &[u8]) -> Result<usize>
{
if buf.len() > core::u32::MAX as usize
{
return Err(Error::BufferTooLarge);
}
let handle = self.handle.lock();
let mut bytes_written = 0;
let success = unsafe {
WriteFile(
*handle,
buf.as_ptr() as _,
buf.len() as _,
&mut bytes_written,
null_mut(),
) != 0
};
match success
{
true => Ok(bytes_written as _),
false => Err(Error::CannotWrite),
}
}
fn flush(&mut self) -> Result<()>
{
let handle = self.handle.lock();
let success = unsafe { FlushFileBuffers(*handle) != 0 };
match success
{
true => Ok(()),
false => Err(Error::CannotFlush),
}
}
}
static STDOUT_ONCE: Once<Stdout> = Once::new();
pub fn stdout() -> &'static Stdout
{
STDOUT_ONCE.get(|| Stdout::new())
}
|
extern crate isatty;
extern crate rayon;
extern crate serde_json;
extern crate solana;
use isatty::stdin_isatty;
use rayon::prelude::*;
use solana::bank::MAX_ENTRY_IDS;
use solana::entry::{next_entry, Entry};
use solana::mint::MintDemo;
use solana::signature::{GenKeys, KeyPairUtil};
use solana::transaction::Transaction;
use std::io::{stdin, Read};
use std::process::exit;
// Generate a ledger with lots and lots of accounts.
fn main() {
if stdin_isatty() {
eprintln!("nothing found on stdin, expected a json file");
exit(1);
}
let mut buffer = String::new();
let num_bytes = stdin().read_to_string(&mut buffer).unwrap();
if num_bytes == 0 {
eprintln!("empty file on stdin, expected a json file");
exit(1);
}
let demo: MintDemo = serde_json::from_str(&buffer).unwrap_or_else(|e| {
eprintln!("failed to parse json: {}", e);
exit(1);
});
let rnd = GenKeys::new(demo.mint.keypair().public_key_bytes());
let num_accounts = demo.num_accounts;
let tokens_per_user = 1_000;
let keypairs = rnd.gen_n_keypairs(num_accounts);
let mint_keypair = demo.mint.keypair();
let last_id = demo.mint.last_id();
for entry in demo.mint.create_entries() {
println!("{}", serde_json::to_string(&entry).unwrap());
}
eprintln!("Creating {} empty entries...", MAX_ENTRY_IDS);
// Offer client lots of entry IDs to use for each transaction's last_id.
let mut last_id = last_id;
let mut last_ids = vec![];
for _ in 0..MAX_ENTRY_IDS {
let entry = next_entry(&last_id, 1, vec![]);
last_id = entry.id;
last_ids.push(last_id);
let serialized = serde_json::to_string(&entry).unwrap_or_else(|e| {
eprintln!("failed to serialize: {}", e);
exit(1);
});
println!("{}", serialized);
}
eprintln!("Creating {} transactions...", num_accounts);
let transactions: Vec<_> = keypairs
.into_par_iter()
.enumerate()
.map(|(i, rando)| {
let last_id = last_ids[i % MAX_ENTRY_IDS];
Transaction::new(&mint_keypair, rando.pubkey(), tokens_per_user, last_id)
})
.collect();
eprintln!("Logging the creation of {} accounts...", num_accounts);
let entry = Entry::new(&last_id, 0, transactions);
println!("{}", serde_json::to_string(&entry).unwrap());
}
|
struct MyQueue {
stack: Vec<i32>,
pop_mode: bool,
}
impl MyQueue {
/** Initialize your data structure here. */
fn new() -> Self {
Self {
stack: vec![],
pop_mode: false,
}
}
/** Push element x to the back of queue. */
fn push(&mut self, x: i32) {
if self.pop_mode {
self.flip();
}
self.stack.push(x)
}
/** Removes the element from in front of queue and returns that element. */
fn pop(&mut self) -> i32 {
if !self.pop_mode {
self.flip();
}
self.stack.pop().unwrap()
}
/** Get the front element. */
fn peek(&mut self) -> i32 {
if !self.pop_mode {
self.flip();
}
*self.stack.last().unwrap()
}
/** Returns whether the queue is empty. */
fn empty(&self) -> bool {
self.stack.is_empty()
}
fn flip(&mut self) {
self.pop_mode = !self.pop_mode;
let mut s = vec![];
while let Some(x) = self.stack.pop() {
s.push(x);
}
self.stack = s;
}
} |
pub mod class;
pub mod property;
pub mod signal;
pub mod window;
pub mod key;
pub use self::property::Property;
pub use self::signal::{Signal, GLOBAL_SIGNALS, signal_object_emit};
pub use self::window::WindowState;
pub use self::key::KeyState;
|
use axum::extract::TypedHeader;
use axum::headers::UserAgent;
use axum::routing::get;
use axum::Router;
use sqlx::{migrate::MigrateDatabase, Sqlite, SqlitePool};
const DB_URL: &str = "sqlite:///tmp/sqlite.db";
async fn homepage() -> String {
String::from("homepage")
}
async fn visit_info(TypedHeader(user_agent): TypedHeader<UserAgent>) -> String {
String::from(user_agent.as_str())
}
async fn init_db() {
if !Sqlite::database_exists(DB_URL).await.unwrap_or(false) {
println!("Creating database {}", DB_URL);
match Sqlite::create_database(DB_URL).await {
Ok(_) => println!("Create db success"),
Err(error) => panic!("error: {}", error),
}
} else {
println!("Database already exists");
}
}
async fn init_tables() {
let db = SqlitePool::connect(DB_URL).await.unwrap();
let result = sqlx::query("CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY NOT NULL, name VARCHAR(250) NOT NULL);").execute(&db).await.unwrap();
println!("Create user table result: {:?}", result);
}
#[tokio::main]
async fn main() {
init_db().await;
init_tables().await;
let app = Router::new()
.route("/", get(homepage))
.route("/visit", get(visit_info));
axum::Server::bind(&"0.0.0.0:4000".parse().unwrap())
.serve(app.into_make_service())
.await
.unwrap();
}
|
fn main() {
let x=[1,2,3];
let y=[1;3];
let read_x= &x[..];
let read_y= &y[0..1];
println!("{}",read_x[0]);
println!("{}",read_y[0]);
}
|
fn main() {
println!("Hello, sela!");
}
|
use std::hash::Hash;
use std::collections::HashMap;
use super::interpret::TurtleCommand;
/// These rules describe how an L-System should evolve to its next
/// state and how this state should be interpreted in order to draw it.
/// These two different concepts are stored alongside to facilitate the definition
/// of L-System, both in code and in file.
///
/// A production (or evolution) rule consists in a symbol combined with its
/// corresponding result. The internal data structure is up to the structures
/// implementing this trait.
///
/// See 'TurtleCommand' for further detail on the interpretation rules.
pub trait LRules<S: Eq> {
/// Get the production of the given symbol, or None if no matching rule is
/// found.
fn production(&self, symbol: &S) -> Option<&Vec<S>>;
/// Get the interpreter command for the given symbol, or None if no matching
/// command is found.
fn interpretation(&self, symbol: &S) -> Option<&TurtleCommand>;
/// Get the expansion size of the worse-case production.
fn biggest_expansion(&self) -> usize;
/// Get the average expansion size of the production rules.
fn average_expansion(&self) -> f64;
}
#[derive(Clone, Debug)]
struct SymbolRule<S: Eq>(Vec<S>, TurtleCommand);
/// HashMap-based Rules structure.
#[derive(Clone, Debug)]
pub struct HashMapRules<S>
where S: Eq + Hash
{
rules: HashMap<S, SymbolRule<S>>,
biggest_expansion: usize,
average_expansion: f64,
}
impl<S> HashMapRules<S>
where S: Eq + Hash
{
pub fn new() -> HashMapRules<S> {
HashMapRules {
rules: HashMap::new(),
biggest_expansion: 0,
average_expansion: 0f64,
}
}
/// Add a new symbol rule or modify an existing one.
/// Return true if an existing rule was modified, false otherwise.
pub fn set(&mut self, symbol: S, production: Vec<S>, interpretation: TurtleCommand) -> bool {
let production_len = production.len();
let modified = match self.rules
.insert(symbol, SymbolRule(production, interpretation)) {
Some(_) => true,
None => false,
};
// biggest expansion computing
if production_len > self.biggest_expansion {
self.biggest_expansion = production_len;
}
// average expansion computing
assert!(self.rules.len() > 0);
self.average_expansion += (production_len as f64 - self.average_expansion) /
(self.rules.len() as f64);
modified
}
}
impl HashMapRules<char> {
/// Convenience method for calling 'set' directly with an str slice.
/// NB: unicode char should be avoided at all cost, which is why ASCII is
/// preferred.
pub fn set_str(&mut self,
symbol: char,
production: &str,
interpretation: TurtleCommand)
-> bool {
self.set(symbol, production.chars().collect(), interpretation)
}
}
impl<S> LRules<S> for HashMapRules<S>
where S: Eq + Hash
{
fn production(&self, symbol: &S) -> Option<&Vec<S>> {
self.rules.get(symbol).map(|r| &r.0)
}
fn interpretation(&self, symbol: &S) -> Option<&TurtleCommand> {
self.rules.get(symbol).map(|r| &r.1)
}
fn biggest_expansion(&self) -> usize {
self.biggest_expansion
}
fn average_expansion(&self) -> f64 {
self.average_expansion
}
}
/// Default, ASCII-only 'HashMapRules' type.
pub type AsciiHashMapRules = HashMapRules<u8>;
impl AsciiHashMapRules {
pub fn set_ascii(&mut self,
symbol: u8,
production: &[u8],
interpretation: TurtleCommand)
-> bool {
self.set(symbol, production.to_vec(), interpretation)
}
}
#[cfg(test)]
mod test {
use super::*;
use interpret::TurtleCommand;
#[test]
fn hashmap_rules_char() {
let mut rules: HashMapRules<char> = HashMapRules::new();
rules.set_str('A', "+B−A−B+", TurtleCommand::AdvanceBy(10f32));
rules.set_str('B', "−A+B+A−", TurtleCommand::AdvanceBy(10f32));
rules.set_str('+', "+", TurtleCommand::RotateBy(60f32));
rules.set_str('-', "-", TurtleCommand::RotateBy(-60f32));
assert_eq!(rules.biggest_expansion(), 7);
assert_eq!(rules.average_expansion(), 4.0);
assert_eq!(rules.production(&'A'),
Some(&"+B−A−B+".chars().collect()));
assert_eq!(rules.production(&'B'),
Some(&"−A+B+A−".chars().collect()));
assert_eq!(rules.production(&'C'), None);
}
#[test]
fn hashmap_rules_ascii() {
let mut rules = AsciiHashMapRules::new();
rules.set_ascii(b'A', b"AB", TurtleCommand::None);
rules.set_ascii(b'B', b"A", TurtleCommand::None);
assert_eq!(rules.biggest_expansion(), 2);
assert_eq!(rules.average_expansion(), 1.5);
assert_eq!(rules.production(&b'A'), Some(&b"AB".to_vec()));
assert_eq!(rules.production(&b'B'), Some(&b"A".to_vec()));
assert_eq!(rules.production(&b'C'), None);
}
}
|
//! Bus provides a lock-free, bounded, single-producer, multi-consumer, broadcast channel.
//!
//! It uses a circular buffer and atomic instructions to implement a lock-free single-producer,
//! multi-consumer channel. The interface is similar to that of the `std::sync::mpsc` channels,
//! except that multiple consumers (readers of the channel) can be produced, whereas only a single
//! sender can exist. Furthermore, in contrast to most multi-consumer FIFO queues, bus is
//! *broadcast*; every send goes to every consumer.
//!
//! I haven't seen this particular implementation in literature (some extra bookkeeping is
//! necessary to allow multiple consumers), but a lot of related reading can be found in Ross
//! Bencina's blog post ["Some notes on lock-free and wait-free
//! algorithms"](http://www.rossbencina.com/code/lockfree).
//!
//! Bus achieves broadcast by cloning the element in question, which is why `T` must implement
//! `Clone`. However, Bus is clever about only cloning when necessary. Specifically, the last
//! consumer to see a given value will move it instead of cloning, which means no cloning is
//! happening for the single-consumer case. For cases where cloning is expensive, `Arc` should be
//! used instead.
//!
//! # Examples
//!
//! Single-send, multi-consumer example
//!
//! ```rust
//! use bus::Bus;
//! let mut bus = Bus::new(10);
//! let mut rx1 = bus.add_rx();
//! let mut rx2 = bus.add_rx();
//!
//! bus.broadcast("Hello");
//! assert_eq!(rx1.recv(), Ok("Hello"));
//! assert_eq!(rx2.recv(), Ok("Hello"));
//! ```
//!
//! Multi-send, multi-consumer example
//!
//! ```rust
//! # if cfg!(miri) { return } // Miri is too slow
//! use bus::Bus;
//! use std::thread;
//!
//! let mut bus = Bus::new(10);
//! let mut rx1 = bus.add_rx();
//! let mut rx2 = bus.add_rx();
//!
//! // start a thread that sends 1..100
//! let j = thread::spawn(move || {
//! for i in 1..100 {
//! bus.broadcast(i);
//! }
//! });
//!
//! // every value should be received by both receivers
//! for i in 1..100 {
//! // rx1
//! assert_eq!(rx1.recv(), Ok(i));
//! // and rx2
//! assert_eq!(rx2.recv(), Ok(i));
//! }
//!
//! j.join().unwrap();
//! ```
//!
//! Many-to-many channel using a dispatcher
//!
//! ```rust
//! use bus::Bus;
//!
//! use std::thread;
//! use std::sync::mpsc;
//!
//! // set up fan-in
//! let (tx1, mix_rx) = mpsc::sync_channel(100);
//! let tx2 = tx1.clone();
//! // set up fan-out
//! let mut mix_tx = Bus::new(100);
//! let mut rx1 = mix_tx.add_rx();
//! let mut rx2 = mix_tx.add_rx();
//! // start dispatcher
//! thread::spawn(move || {
//! for m in mix_rx.iter() {
//! mix_tx.broadcast(m);
//! }
//! });
//!
//! // sends on tx1 are received ...
//! tx1.send("Hello").unwrap();
//!
//! // ... by both receiver rx1 ...
//! assert_eq!(rx1.recv(), Ok("Hello"));
//! // ... and receiver rx2
//! assert_eq!(rx2.recv(), Ok("Hello"));
//!
//! // same with sends on tx2
//! tx2.send("world").unwrap();
//! assert_eq!(rx1.recv(), Ok("world"));
//! assert_eq!(rx2.recv(), Ok("world"));
//! ```
#![deny(missing_docs)]
#![warn(rust_2018_idioms)]
use crossbeam_channel as mpsc;
use parking_lot_core::SpinWait;
use std::cell::UnsafeCell;
use std::fmt;
use std::marker::PhantomData;
use std::ops::Deref;
use std::ptr;
use std::sync::atomic;
use std::sync::mpsc as std_mpsc;
use std::sync::Arc;
use std::thread;
use std::time;
const SPINTIME: u32 = 100_000; //ns
struct SeatState<T> {
max: usize,
val: Option<T>,
}
struct MutSeatState<T>(UnsafeCell<SeatState<T>>);
unsafe impl<T> Sync for MutSeatState<T> {}
impl<T> Deref for MutSeatState<T> {
type Target = UnsafeCell<SeatState<T>>;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl<T> fmt::Debug for MutSeatState<T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_tuple("MutSeatState").field(&self.0).finish()
}
}
/// A Seat is a single location in the circular buffer.
/// Each Seat knows how many readers are expected to access it, as well as how many have. The
/// producer will never modify a seat's state unless all readers for a particular seat have either
/// called `.take()` on it, or have left (see `Bus.rleft`).
///
/// The producer walks the seats of the ring in order, and will always only modify the seat at
/// `tail + 1` once all readers have finished with the seat at `head + 2`. A reader will never
/// access a seat unless it is between the reader's `head` and the producer's `tail`. Together,
/// these properties ensure that a Seat is either accessed only by readers, or by only the
/// producer.
///
/// The `read` attribute is used to ensure that readers see the most recent write to the seat when
/// they access it. This is done using `atomic::Ordering::Acquire` and `atomic::Ordering::Release`.
struct Seat<T> {
read: atomic::AtomicUsize,
state: MutSeatState<T>,
// is the writer waiting for this seat to be emptied? needs to be atomic since both the last
// reader and the writer might be accessing it at the same time.
waiting: AtomicOption<thread::Thread>,
}
impl<T> fmt::Debug for Seat<T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Seat")
.field("read", &self.read)
.field("state", &self.state)
.field("waiting", &self.waiting)
.finish()
}
}
impl<T: Clone + Sync> Seat<T> {
/// take is used by a reader to extract a copy of the value stored on this seat. only readers
/// that were created strictly before the time this seat was last written to by the producer
/// are allowed to call this method, and they may each only call it once.
fn take(&self) -> T {
let read = self.read.load(atomic::Ordering::Acquire);
// the writer will only modify this element when .read hits .max - writer.rleft[i]. we can
// be sure that this is not currently the case (which means it's safe for us to read)
// because:
//
// - .max is set to the number of readers at the time when the write happens
// - any joining readers will start at a later seat
// - so, at most .max readers will call .take() on this seat this time around the buffer
// - a reader must leave either *before* or *after* a call to recv. there are two cases:
//
// - it leaves before, rleft is decremented, but .take is not called
// - it leaves after, .take is called, but head has been incremented, so rleft will be
// decremented for the *next* seat, not this one
//
// so, either .take is called, and .read is incremented, or writer.rleft is incremented.
// thus, for a writer to modify this element, *all* readers at the time of the previous
// write to this seat must have either called .take or have left.
// - since we are one of those readers, this cannot be true, so it's safe for us to assume
// that there is no concurrent writer for this seat
let state = unsafe { &*self.state.get() };
assert!(
read < state.max,
"reader hit seat with exhausted reader count"
);
let mut waiting = None;
// NOTE
// we must extract the value *before* we decrement the number of remaining items otherwise,
// the object might be replaced by the time we read it!
let v = if read + 1 == state.max {
// we're the last reader, so we may need to notify the writer there's space in the buf.
// can be relaxed, since the acquire at the top already guarantees that we'll see
// updates.
waiting = self.waiting.take();
// since we're the last reader, no-one else will be cloning this value, so we can
// safely take a mutable reference, and just take the val instead of cloning it.
unsafe { &mut *self.state.get() }.val.take().unwrap()
} else {
let v = state
.val
.clone()
.expect("seat that should be occupied was empty");
// let writer know that we no longer need this item.
// state is no longer safe to access.
#[allow(clippy::drop_ref)]
drop(state);
v
};
self.read.fetch_add(1, atomic::Ordering::AcqRel);
if let Some(t) = waiting {
// writer was waiting for us to finish with this
t.unpark();
}
v
}
}
impl<T> Default for Seat<T> {
fn default() -> Self {
Seat {
read: atomic::AtomicUsize::new(0),
waiting: AtomicOption::empty(),
state: MutSeatState(UnsafeCell::new(SeatState { max: 0, val: None })),
}
}
}
/// `BusInner` encapsulates data that both the writer and the readers need to access. The tail is
/// only ever modified by the producer, and read by the consumers. The length of the bus is
/// instantiated when the bus is created, and is never modified.
struct BusInner<T> {
ring: Vec<Seat<T>>,
len: usize,
tail: atomic::AtomicUsize,
closed: atomic::AtomicBool,
}
impl<T> fmt::Debug for BusInner<T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("BusInner")
.field("ring", &self.ring)
.field("len", &self.len)
.field("tail", &self.tail)
.field("closed", &self.closed)
.finish()
}
}
/// `Bus` is the main interconnect for broadcast messages. It can be used to send broadcast
/// messages, or to connect additional consumers. When the `Bus` is dropped, receivers will
/// continue receiving any outstanding broadcast messages they would have received if the bus were
/// not dropped. After all those messages have been received, any subsequent receive call on a
/// receiver will return a disconnected error.
pub struct Bus<T> {
state: Arc<BusInner<T>>,
// current number of readers
readers: usize,
// rleft keeps track of readers that should be skipped for each index. we must do this because
// .read will be < max for those indices, even though all active readers have received them.
rleft: Vec<usize>,
// leaving is used by receivers to signal that they are done
leaving: (mpsc::Sender<usize>, mpsc::Receiver<usize>),
// waiting is used by receivers to signal that they are waiting for new entries, and where they
// are waiting
#[allow(clippy::type_complexity)]
waiting: (
mpsc::Sender<(thread::Thread, usize)>,
mpsc::Receiver<(thread::Thread, usize)>,
),
// channel used to communicate to unparker that a given thread should be woken up
unpark: mpsc::Sender<thread::Thread>,
// cache used to keep track of threads waiting for next write.
// this is only here to avoid allocating one on every broadcast()
cache: Vec<(thread::Thread, usize)>,
}
impl<T> fmt::Debug for Bus<T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Bus")
.field("state", &self.state)
.field("readers", &self.readers)
.field("rleft", &self.rleft)
.field("leaving", &self.leaving)
.field("waiting", &self.waiting)
.field("unpark", &self.unpark)
.field("cache", &self.cache)
.finish()
}
}
impl<T> Bus<T> {
/// Allocates a new `Bus`.
///
/// The provided length should be sufficient to absorb temporary peaks in the data flow, and is
/// thus workflow-dependent. Bus performance degrades somewhat when the queue is full, so it is
/// generally better to set this high than low unless you are pressed for memory.
pub fn new(mut len: usize) -> Bus<T> {
use std::iter;
// ring buffer must have room for one padding element
len += 1;
let inner = Arc::new(BusInner {
ring: (0..len).map(|_| Seat::default()).collect(),
tail: atomic::AtomicUsize::new(0),
closed: atomic::AtomicBool::new(false),
len,
});
// work around https://github.com/rust-lang/rust/issues/59020
if !cfg!(miri) && cfg!(target = "macos") {
let _ = time::Instant::now().elapsed();
}
// we run a separate thread responsible for unparking
// so we don't have to wait for unpark() to return in broadcast_inner
// sending on a channel without contention is cheap, unparking is not
let (unpark_tx, unpark_rx) = mpsc::unbounded::<thread::Thread>();
let _ = thread::Builder::new()
.name("bus_unparking".to_owned())
.spawn(move || {
for t in unpark_rx.iter() {
t.unpark();
}
});
Bus {
state: inner,
readers: 0,
rleft: iter::repeat(0).take(len).collect(),
leaving: mpsc::unbounded(),
waiting: mpsc::unbounded(),
unpark: unpark_tx,
cache: Vec::new(),
}
}
/// Get the expected number of reads for the given seat. This number will always be
/// conservative, in that fewer reads may be fine. Specifically, `.rleft` may not be
/// sufficiently up-to-date to account for all readers that have left.
#[inline]
fn expected(&mut self, at: usize) -> usize {
// since only the producer will modify the ring, and &mut self guarantees that *we* are the
// producer, no-one is modifying the ring. Multiple read-only borrows are safe, and so the
// cast below is safe.
unsafe { &*self.state.ring[at].state.get() }.max - self.rleft[at]
}
/// Attempts to place the given value on the bus.
///
/// If the bus is full, the behavior depends on `block`. If false, the value given is returned
/// in an `Err()`. Otherwise, the current thread will be parked until there is space in the bus
/// again, and the broadcast will be tried again until it succeeds.
///
/// Note that broadcasts will succeed even if there are no consumers!
fn broadcast_inner(&mut self, val: T, block: bool) -> Result<(), T> {
let tail = self.state.tail.load(atomic::Ordering::Relaxed);
// we want to check if the next element over is free to ensure that we always leave one
// empty space between the head and the tail. This is necessary so that readers can
// distinguish between an empty and a full list. If the fence seat is free, the seat at
// tail must also be free, which is simple enough to show by induction (exercise for the
// reader).
let fence = (tail + 1) % self.state.len;
let spintime = time::Duration::new(0, SPINTIME);
// to avoid parking when a slot frees up quickly, we use an exponential back-off SpinWait.
let mut sw = SpinWait::new();
loop {
let fence_read = self.state.ring[fence].read.load(atomic::Ordering::Acquire);
// is there room left in the ring?
if fence_read == self.expected(fence) {
break;
}
// no!
// let's check if any readers have left, which might increment self.rleft[tail].
while let Ok(mut left) = self.leaving.1.try_recv() {
// a reader has left! this means that every seat between `left` and `tail-1`
// has max set one too high. we track the number of such "missing" reads that
// should be ignored in self.rleft, and compensate for them when looking at
// seat.read above.
self.readers -= 1;
while left != tail {
self.rleft[left] += 1;
left = (left + 1) % self.state.len
}
}
// is the fence block now free?
if fence_read == self.expected(fence) {
// yes! go ahead and write!
break;
} else if block {
// no, so block by parking and telling readers to notify on last read
self.state.ring[fence]
.waiting
.swap(Some(Box::new(thread::current())));
// need the atomic fetch_add to ensure reader threads will see the new .waiting
self.state.ring[fence]
.read
.fetch_add(0, atomic::Ordering::Release);
if !sw.spin() {
// not likely to get a slot soon -- wait to be unparked instead.
// note that we *need* to wait, because there are some cases in which we
// *won't* be unparked even though a slot has opened up.
thread::park_timeout(spintime);
}
continue;
} else {
// no, and blocking isn't allowed, so return an error
return Err(val);
}
}
// next one over is free, we have a free seat!
let readers = self.readers;
{
let next = &self.state.ring[tail];
// we are the only writer, so no-one else can be writing. however, since we're
// mutating state, we also need for there to be no readers for this to be safe. the
// argument for why this is the case is roughly an inverse of the argument for why
// the unsafe block in Seat.take() is safe. basically, since
//
// .read + .rleft == .max
//
// we know all readers at the time of the seat's previous write have accessed this
// seat. we also know that no other readers will access that seat (they must have
// started at later seats). thus, we are the only thread accessing this seat, and
// so we can safely access it as mutable.
let state = unsafe { &mut *next.state.get() };
state.max = readers;
state.val = Some(val);
next.waiting.take();
next.read.store(0, atomic::Ordering::Release);
}
self.rleft[tail] = 0;
// now tell readers that they can read
let tail = (tail + 1) % self.state.len;
self.state.tail.store(tail, atomic::Ordering::Release);
// unblock any blocked receivers
while let Ok((t, at)) = self.waiting.1.try_recv() {
// the only readers we can't unblock are those that have already absorbed the
// broadcast we just made, since they are blocking on the *next* broadcast
if at == tail {
self.cache.push((t, at))
} else {
self.unpark.send(t).unwrap();
}
}
for w in self.cache.drain(..) {
// fine to do here because it is guaranteed not to block
self.waiting.0.send(w).unwrap();
}
Ok(())
}
/// Attempt to broadcast the given value to all consumers, but does not block if full.
///
/// Note that, in contrast to regular channels, a bus is *not* considered closed if there are
/// no consumers, and thus broadcasts will continue to succeed. Thus, a successful broadcast
/// occurs as long as there is room on the internal bus to store the value, or some older value
/// has been received by all consumers. Note that a return value of `Err` means that the data
/// will never be received (by any consumer), but a return value of Ok does not mean that the
/// data will be received by a given consumer. It is possible for a receiver to hang up
/// immediately after this function returns Ok.
///
/// This method will never block the current thread.
///
/// ```rust
/// use bus::Bus;
/// let mut tx = Bus::new(1);
/// let mut rx = tx.add_rx();
/// assert_eq!(tx.try_broadcast("Hello"), Ok(()));
/// assert_eq!(tx.try_broadcast("world"), Err("world"));
/// ```
pub fn try_broadcast(&mut self, val: T) -> Result<(), T> {
self.broadcast_inner(val, false)
}
/// Broadcasts a value on the bus to all consumers.
///
/// This function will block until space in the internal buffer becomes available.
///
/// Note that a successful send does not guarantee that the receiver will ever see the data if
/// there is a buffer on this channel. Items may be enqueued in the internal buffer for the
/// receiver to receive at a later time. Furthermore, in contrast to regular channels, a bus is
/// *not* considered closed if there are no consumers, and thus broadcasts will continue to
/// succeed.
pub fn broadcast(&mut self, val: T) {
if let Err(..) = self.broadcast_inner(val, true) {
unreachable!("blocking broadcast_inner can't fail");
}
}
/// Add a new consumer to this bus.
///
/// The new consumer will receive all *future* broadcasts on this bus.
///
/// # Examples
///
/// ```rust
/// use bus::Bus;
/// use std::sync::mpsc::TryRecvError;
///
/// let mut bus = Bus::new(10);
/// let mut rx1 = bus.add_rx();
///
/// bus.broadcast("Hello");
///
/// // consumer present during broadcast sees update
/// assert_eq!(rx1.recv(), Ok("Hello"));
///
/// // new consumer does *not* see broadcast
/// let mut rx2 = bus.add_rx();
/// assert_eq!(rx2.try_recv(), Err(TryRecvError::Empty));
///
/// // both consumers see new broadcast
/// bus.broadcast("world");
/// assert_eq!(rx1.recv(), Ok("world"));
/// assert_eq!(rx2.recv(), Ok("world"));
/// ```
pub fn add_rx(&mut self) -> BusReader<T> {
self.readers += 1;
BusReader {
bus: Arc::clone(&self.state),
head: self.state.tail.load(atomic::Ordering::Relaxed),
leaving: self.leaving.0.clone(),
waiting: self.waiting.0.clone(),
closed: false,
}
}
/// Returns the number of active consumers currently attached to this bus.
///
/// It is not guaranteed that a sent message will reach this number of consumers, as active
/// consumers may never call `recv` or `try_recv` again before dropping.
///
/// # Examples
///
/// ```rust
/// use bus::Bus;
///
/// let mut bus = Bus::<u8>::new(10);
/// assert_eq!(bus.rx_count(), 0);
///
/// let rx1 = bus.add_rx();
/// assert_eq!(bus.rx_count(), 1);
///
/// drop(rx1);
/// assert_eq!(bus.rx_count(), 0);
/// ```
pub fn rx_count(&self) -> usize {
self.readers - self.leaving.1.len()
}
}
impl<T> Drop for Bus<T> {
fn drop(&mut self) {
self.state.closed.store(true, atomic::Ordering::Relaxed);
// Acquire/Release .tail to ensure other threads see new .closed
self.state.tail.fetch_add(0, atomic::Ordering::AcqRel);
// TODO: unpark receivers -- this is not absolutely necessary, since the reader's park will
// time out, but it would cause them to detect the closed bus somewhat faster.
}
}
#[derive(Clone, Copy)]
enum RecvCondition {
Try,
Block,
Timeout(time::Duration),
}
/// A `BusReader` is a single consumer of `Bus` broadcasts. It will see every new value that is
/// passed to `.broadcast()` (or successful calls to `.try_broadcast()`) on the `Bus` that it was
/// created from.
///
/// Dropping a `BusReader` is perfectly safe, and will unblock the writer if it was waiting for
/// that read to see a particular update.
///
/// ```rust
/// use bus::Bus;
/// let mut tx = Bus::new(1);
/// let mut r1 = tx.add_rx();
/// let r2 = tx.add_rx();
/// assert_eq!(tx.try_broadcast(true), Ok(()));
/// assert_eq!(r1.recv(), Ok(true));
///
/// // the bus does not have room for another broadcast
/// // since it knows r2 has not yet read the first broadcast
/// assert_eq!(tx.try_broadcast(true), Err(true));
///
/// // dropping r2 tells the producer that there is a free slot
/// // (i.e., it has been read by everyone)
/// drop(r2);
/// assert_eq!(tx.try_broadcast(true), Ok(()));
/// ```
pub struct BusReader<T> {
bus: Arc<BusInner<T>>,
head: usize,
leaving: mpsc::Sender<usize>,
waiting: mpsc::Sender<(thread::Thread, usize)>,
closed: bool,
}
impl<T> fmt::Debug for BusReader<T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("BusReader")
.field("bus", &self.bus)
.field("head", &self.head)
.field("leaving", &self.leaving)
.field("waiting", &self.waiting)
.field("closed", &self.closed)
.finish()
}
}
impl<T: Clone + Sync> BusReader<T> {
/// Attempts to read a broadcast from the bus.
///
/// If the bus is empty, the behavior depends on `block`. If false,
/// `Err(mpsc::RecvTimeoutError::Timeout)` is returned. Otherwise, the current thread will be
/// parked until there is another broadcast on the bus, at which point the receive will be
/// performed.
fn recv_inner(&mut self, block: RecvCondition) -> Result<T, std_mpsc::RecvTimeoutError> {
if self.closed {
return Err(std_mpsc::RecvTimeoutError::Disconnected);
}
let start = match block {
RecvCondition::Timeout(_) => Some(time::Instant::now()),
_ => None,
};
let spintime = time::Duration::new(0, SPINTIME);
let mut was_closed = false;
let mut sw = SpinWait::new();
let mut first = true;
loop {
let tail = self.bus.tail.load(atomic::Ordering::Acquire);
if tail != self.head {
break;
}
// buffer is empty, check whether it's closed.
// relaxed is fine since Bus.drop does an acquire/release on tail
if self.bus.closed.load(atomic::Ordering::Relaxed) {
// we need to check again that there's nothing in the bus, otherwise we might have
// missed a write between when we did the read of .tail above and when we read
// .closed here
if !was_closed {
was_closed = true;
continue;
}
// the bus is closed, and we didn't miss anything!
self.closed = true;
return Err(std_mpsc::RecvTimeoutError::Disconnected);
}
// not closed, should we block?
if let RecvCondition::Try = block {
return Err(std_mpsc::RecvTimeoutError::Timeout);
}
// park and tell writer to notify on write
if first {
if let Err(..) = self.waiting.send((thread::current(), self.head)) {
// writer has gone away, but somehow we _just_ missed the close signal (in
// self.bus.closed). iterate again to ensure the channel is _actually_ empty.
atomic::fence(atomic::Ordering::SeqCst);
continue;
}
first = false;
}
if !sw.spin() {
match block {
RecvCondition::Timeout(t) => {
match t.checked_sub(start.as_ref().unwrap().elapsed()) {
Some(left) => {
if left < spintime {
thread::park_timeout(left);
} else {
thread::park_timeout(spintime);
}
}
None => {
// So, the wake-up thread is still going to try to wake us up later
// since we sent thread::current() above, but that's fine.
return Err(std_mpsc::RecvTimeoutError::Timeout);
}
}
}
RecvCondition::Block => {
thread::park_timeout(spintime);
}
RecvCondition::Try => unreachable!(),
}
}
}
let head = self.head;
let ret = self.bus.ring[head].take();
// safe because len is read-only
self.head = (head + 1) % self.bus.len;
Ok(ret)
}
/// Attempts to return a pending broadcast on this receiver without blocking.
///
/// This method will never block the caller in order to wait for data to become available.
/// Instead, this will always return immediately with a possible option of pending data on the
/// channel.
///
/// If the corresponding bus has been dropped, and all broadcasts have been received, this
/// method will return with a disconnected error.
///
/// This method is useful for a flavor of "optimistic check" before deciding to block on a
/// receiver.
///
/// ```rust
/// use bus::Bus;
/// use std::thread;
///
/// let mut tx = Bus::new(10);
/// let mut rx = tx.add_rx();
///
/// // spawn a thread that will broadcast at some point
/// let j = thread::spawn(move || {
/// tx.broadcast(true);
/// });
///
/// loop {
/// match rx.try_recv() {
/// Ok(val) => {
/// assert_eq!(val, true);
/// break;
/// }
/// Err(..) => {
/// // maybe we can do other useful work here
/// // or we can just busy-loop
/// thread::yield_now()
/// },
/// }
/// }
///
/// j.join().unwrap();
/// ```
pub fn try_recv(&mut self) -> Result<T, std_mpsc::TryRecvError> {
self.recv_inner(RecvCondition::Try).map_err(|e| match e {
std_mpsc::RecvTimeoutError::Disconnected => std_mpsc::TryRecvError::Disconnected,
std_mpsc::RecvTimeoutError::Timeout => std_mpsc::TryRecvError::Empty,
})
}
/// Read another broadcast message from the bus, and block if none are available.
///
/// This function will always block the current thread if there is no data available and it's
/// possible for more broadcasts to be sent. Once a broadcast is sent on the corresponding
/// `Bus`, then this receiver will wake up and return that message.
///
/// If the corresponding `Bus` has been dropped, or it is dropped while this call is blocking,
/// this call will wake up and return `Err` to indicate that no more messages can ever be
/// received on this channel. However, since channels are buffered, messages sent before the
/// disconnect will still be properly received.
pub fn recv(&mut self) -> Result<T, std_mpsc::RecvError> {
match self.recv_inner(RecvCondition::Block) {
Ok(val) => Ok(val),
Err(std_mpsc::RecvTimeoutError::Disconnected) => Err(std_mpsc::RecvError),
_ => unreachable!("blocking recv_inner can't fail"),
}
}
/// Attempts to wait for a value from the bus, returning an error if the corresponding channel
/// has hung up, or if it waits more than `timeout`.
///
/// This function will always block the current thread if there is no data available and it's
/// possible for more broadcasts to be sent. Once a message is sent on the corresponding `Bus`,
/// then this receiver will wake up and return that message.
///
/// If the corresponding `Bus` has been dropped, or it is dropped while this call is blocking,
/// this call will wake up and return Err to indicate that no more messages can ever be
/// received on this channel. However, since channels are buffered, messages sent before the
/// disconnect will still be properly received.
///
/// # Examples
///
/// ```rust
/// use bus::Bus;
/// use std::sync::mpsc::RecvTimeoutError;
/// use std::time::Duration;
///
/// let mut tx = Bus::<bool>::new(10);
/// let mut rx = tx.add_rx();
///
/// let timeout = Duration::from_millis(100);
/// assert_eq!(Err(RecvTimeoutError::Timeout), rx.recv_timeout(timeout));
/// ```
pub fn recv_timeout(
&mut self,
timeout: time::Duration,
) -> Result<T, std_mpsc::RecvTimeoutError> {
self.recv_inner(RecvCondition::Timeout(timeout))
}
}
impl<T> BusReader<T> {
/// Returns an iterator that will block waiting for broadcasts. It will return `None` when the
/// bus has been closed (i.e., the `Bus` has been dropped).
pub fn iter(&mut self) -> BusIter<'_, T> {
BusIter(self)
}
}
impl<T> Drop for BusReader<T> {
#[allow(unused_must_use)]
fn drop(&mut self) {
// we allow not checking the result here because the writer might have gone away, which
// would result in an error, but is okay nonetheless.
self.leaving.send(self.head);
}
}
/// An iterator over messages on a receiver. This iterator will block whenever `next` is called,
/// waiting for a new message, and `None` will be returned when the corresponding channel has been
/// closed.
pub struct BusIter<'a, T>(&'a mut BusReader<T>);
/// An owning iterator over messages on a receiver. This iterator will block whenever `next` is
/// called, waiting for a new message, and `None` will be returned when the corresponding bus has
/// been closed.
pub struct BusIntoIter<T>(BusReader<T>);
impl<'a, T: Clone + Sync> IntoIterator for &'a mut BusReader<T> {
type Item = T;
type IntoIter = BusIter<'a, T>;
fn into_iter(self) -> BusIter<'a, T> {
BusIter(self)
}
}
impl<T: Clone + Sync> IntoIterator for BusReader<T> {
type Item = T;
type IntoIter = BusIntoIter<T>;
fn into_iter(self) -> BusIntoIter<T> {
BusIntoIter(self)
}
}
impl<'a, T: Clone + Sync> Iterator for BusIter<'a, T> {
type Item = T;
fn next(&mut self) -> Option<T> {
self.0.recv().ok()
}
}
impl<T: Clone + Sync> Iterator for BusIntoIter<T> {
type Item = T;
fn next(&mut self) -> Option<T> {
self.0.recv().ok()
}
}
struct AtomicOption<T> {
ptr: atomic::AtomicPtr<T>,
_marker: PhantomData<Option<Box<T>>>,
}
impl<T> fmt::Debug for AtomicOption<T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("AtomicOption")
.field("ptr", &self.ptr)
.finish()
}
}
unsafe impl<T: Send> Send for AtomicOption<T> {}
unsafe impl<T: Send> Sync for AtomicOption<T> {}
impl<T> AtomicOption<T> {
fn empty() -> Self {
Self {
ptr: atomic::AtomicPtr::new(ptr::null_mut()),
_marker: PhantomData,
}
}
fn swap(&self, val: Option<Box<T>>) -> Option<Box<T>> {
let old = match val {
Some(val) => self.ptr.swap(Box::into_raw(val), atomic::Ordering::AcqRel),
// Acquire is needed to synchronize with the store of a non-null ptr, but since a null ptr
// will never be dereferenced, there is no need to synchronize the store of a null ptr.
None => self.ptr.swap(ptr::null_mut(), atomic::Ordering::Acquire),
};
if old.is_null() {
None
} else {
// SAFETY:
// - AcqRel/Acquire ensures that it does not read a pointer to potentially invalid memory.
// - We've checked that old is not null.
// - We do not store invalid pointers other than null in self.ptr.
Some(unsafe { Box::from_raw(old) })
}
}
fn take(&self) -> Option<Box<T>> {
self.swap(None)
}
}
impl<T> Drop for AtomicOption<T> {
fn drop(&mut self) {
drop(self.take());
}
}
|
mod binary_image;
mod color_image;
mod util;
pub use binary_image::*;
pub use color_image::*; |
#![feature(slice_patterns)]
extern crate sdl2;
extern crate gl;
mod vecmath;
mod renderer;
mod logic;
mod primitives;
mod game;
use game::*;
use sdl2::event::Event;
use sdl2::keyboard::Keycode;
use sdl2::mouse::MouseButton;
fn main() {
let sdl = sdl2::init().unwrap();
let video = sdl.video().unwrap();
let mut time = sdl.timer().unwrap();
let gl_attr = video.gl_attr();
gl_attr.set_context_profile(sdl2::video::GLProfile::Core);
gl_attr.set_context_flags().debug().set();
gl_attr.set_context_version(3, 3);
// gl_attr.set_multisample_buffers(1);
// gl_attr.set_multisample_samples(8);
let window = video.window("Test", 800, 600)
.opengl()
.build()
.unwrap();
let glc = window.gl_create_context().unwrap();
window.gl_make_current(&glc).unwrap();
gl::load_with(|name| video.gl_get_proc_address(name) as *const _);
let mut event_pump = sdl.event_pump().unwrap();
let sz = window.size();
let w = sz.0 as f32;
let h = sz.1 as f32;
let mut game = Game::new();
game.on_init(w, h);
let timeStep = 1.0f32 / 60.0;
let mut startTime = 0f32;
let mut accum = 0f32;
let mut button_down = false;
let mut mouse_button = MouseButton::Left;
'running: loop {
let current = time.ticks() as f32 / 1000.0;
let delta = current - startTime;
startTime = current;
accum += delta;
while accum >= timeStep {
accum -= timeStep;
for event in event_pump.poll_iter() {
match event {
Event::Quit {..} => {
break 'running
},
Event::KeyDown { keycode, .. } => {
match keycode {
Some(k) => { game.on_key_press(k); },
None => {}
}
},
Event::MouseButtonDown { mouse_btn, x, y, .. } => {
mouse_button = mouse_btn;
game.on_mouse_click(mouse_btn, x as f32, y as f32);
button_down = true;
},
Event::MouseButtonUp { mouse_btn, .. } => {
game.on_mouse_release(mouse_btn);
button_down = false;
},
Event::MouseMotion { x, y, .. } => {
game.on_mouse_move(x as f32, y as f32);
if button_down {
game.on_mouse_drag(mouse_button, x as f32, y as f32);
}
}
_ => {}
}
}
game.on_update(timeStep);
}
game.on_render(w, h);
window.gl_swap_window();
}
}
|
// Copyright 2018 Chao Lin & William Sergeant (Sorbonne University)
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#![macro_use]
use middle::analysis::ast::*;
use ast::Expression::*;
use std::cmp;
use syntax::codemap::BytePos;
pub use rust::NO_EXPANSION;
enum Predicate {
And(usize),
Not(usize),
Oom(usize),
Zom(usize),
Nothing
}
enum VecType {
And,
OneOrMore,
Nothing
}
pub struct UselessChaining<'a: 'c, 'b: 'a, 'c>
{
grammar: &'c AGrammar<'a, 'b>,
pred: Predicate,
vec_pred : Vec<Predicate>,
vec_type : VecType
}
impl <'a, 'b, 'c> UselessChaining<'a, 'b, 'c>
{
pub fn analyse(grammar: AGrammar<'a, 'b>) -> Partial<AGrammar<'a, 'b>> {
UselessChaining::check_chaining(&grammar);
Partial::Value(grammar)
}
fn check_chaining(grammar: &'c AGrammar<'a, 'b>){
let mut analyser = UselessChaining{
grammar: grammar,
pred: Predicate::Nothing,
vec_pred: vec![],
vec_type: VecType::Nothing
};
for rule in &grammar.rules {
analyser.visit_expr(rule.expr_idx)
}
}
fn span_end_point(&self, sp: Span) -> Span{
let lo = cmp::max(sp.hi().0 - 1, sp.lo().0);
sp.with_lo(BytePos(lo))
}
fn get_th(&self, n: usize) -> &'static str {
match n {
1 => "st",
2 => "nd",
3 => "rd",
_ => "th"
}
}
fn warn_useless_chaining(&self, pred: (&'static str, &'static str, &'static str, &'static str), span2: Span, span1: Span){
let (detected,help,first,second) = pred;
self.grammar.span_warn(
span1,
format!(
"Detected useless chaining: {}
\nHelp: {}
\n1{} predicate {}"
,detected,help,self.get_th(1),first)
);
self.grammar.span_note(
span2,
format!("2{} predicate {}",self.get_th(2),second)
)
}
fn warn_vec_useless_chaining(&self, pred: (&'static str, &'static str, &'static str), i: usize, span: Span){
let (warn,note,span_note) = pred;
if i==0 {
self.grammar.span_warn(
span,
format!(
"Detected useless chaining: multiple {}
\nHelp: {}
\n1{} occurence of {}"
,warn,note,self.get_th(1),warn)
)
}
else{
self.grammar.span_note(
span,
format!("{}{} occurence of {}",i+1,self.get_th(i+1),span_note)
)
}
}
fn warn_verify_multiple(&self) {
for (i, x) in self.vec_pred.iter().enumerate() {
match x {
&Predicate::And(this) => {
let lo = self.grammar[this].span().lo();
let span = Span::new(lo,lo,NO_EXPANSION);
self.warn_vec_useless_chaining(("&","&(&e) -> &e","and"),i,span);
}
&Predicate::Oom(this) => {
let sp = self.grammar[this].span();
let span = self.span_end_point(sp);
self.warn_vec_useless_chaining(("+","(e+)+ -> e+","one or more"),i,span);
}
_ => unreachable!()
}
}
}
fn verify_multiple(&mut self){
if self.vec_pred.len()>=2 {
self.warn_verify_multiple()
}
self.vec_pred.clear();
self.vec_type=VecType::Nothing;
}
fn warning(&mut self, current: Predicate){
match (&self.pred, current) {
(&Predicate::Zom(t),Predicate::Oom(this)) => {
self.warn_useless_chaining(
("(e+)*","(e+)* -> e+","One or more","Zero or more"),
self.span_end_point(self.grammar[this].span()),
self.span_end_point(self.grammar[t].span())
);
}
(&Predicate::Not(t),Predicate::Not(this)) => {
let f_lo = self.grammar[this].span().lo();
let s_lo = self.grammar[t].span().lo();
self.warn_useless_chaining(
("!(!e)","!(!e) -> &e","not","not"),
Span::new(f_lo, f_lo, NO_EXPANSION),
Span::new(s_lo, s_lo, NO_EXPANSION)
);
}
(&Predicate::And(t),Predicate::Not(this)) => {
let f_lo = self.grammar[this].span().lo();
let s_lo = self.grammar[t].span().lo();
self.warn_useless_chaining(
("&(!e)","&(!e) -> !e","not","and"),
Span::new(f_lo, f_lo, NO_EXPANSION),
Span::new(s_lo, s_lo, NO_EXPANSION)
);
}
(&Predicate::Not(t),Predicate::And(this)) => {
let f_lo = self.grammar[this].span().lo();
let s_lo = self.grammar[t].span().lo();
self.warn_useless_chaining(
("!(&e)","!(&e) -> !e","and","not"),
Span::new(f_lo, f_lo, NO_EXPANSION),
Span::new(s_lo, s_lo, NO_EXPANSION)
);
}
_ => {}
}
}
}
impl<'a, 'b, 'c> ExprByIndex for UselessChaining<'a, 'b, 'c>
{
fn expr_by_index(&self, index: usize) -> Expression {
self.grammar.expr_by_index(index).clone()
}
}
impl<'a, 'b, 'c> Visitor<()> for UselessChaining<'a, 'b, 'c>
{
fn visit_str_literal(&mut self, _this: usize, _lit: String){
self.pred=Predicate::Nothing;
self.verify_multiple();
}
fn visit_atom(&mut self, _this: usize){
self.pred=Predicate::Nothing;
self.verify_multiple();
}
fn visit_non_terminal_symbol(&mut self, _this: usize, rule: Ident){
let predicate = self.grammar.find_rule_by_ident(rule).expr_idx;
match self.expr_by_index(predicate){
ZeroOrMore(_child) => {
self.warning(Predicate::Zom(predicate));
}
OneOrMore(_child) => {
self.warning(Predicate::Oom(predicate));
match self.vec_type {
VecType::OneOrMore => {
self.vec_pred.push(Predicate::Oom(predicate));
}
_ => ()
}
}
NotPredicate(_child) => {
self.warning(Predicate::Not(predicate));
}
AndPredicate(_child) => {
self.warning(Predicate::And(predicate));
match self.vec_type {
VecType::And => {
self.vec_pred.push(Predicate::And(predicate));
}
_ => ()
}
}
_ => {}
}
self.pred=Predicate::Nothing;
self.verify_multiple();
}
fn visit_one_or_more(&mut self, this: usize, child: usize){
// println!("one_or_more");
self.warning(Predicate::Oom(this));
match self.vec_type {
VecType::And => {
self.verify_multiple()
}
VecType::Nothing => {
self.vec_type=VecType::OneOrMore
}
_ => ()
}
self.vec_pred.push(Predicate::Oom(this));
self.visit_expr(child)
}
fn visit_zero_or_more(&mut self, this: usize, child: usize){
// println!("zero_or_more");
self.pred = Predicate::Zom(this);
self.verify_multiple();
self.visit_expr(child)
}
fn visit_not_predicate(&mut self, this: usize, child: usize){
// println!("not_predicate");
self.warning(Predicate::Not(this));
self.pred=Predicate::Not(this);
self.verify_multiple();
self.visit_expr(child)
}
fn visit_and_predicate(&mut self, this: usize, child: usize){
// println!("and_predicate");
self.warning(Predicate::And(this));
self.pred=Predicate::And(this);
match self.vec_type {
VecType::OneOrMore => {
self.verify_multiple()
}
VecType::Nothing => {
self.vec_type=VecType::And;
}
_ => ()
}
self.vec_pred.push(Predicate::And(this));
self.visit_expr(child)
}
fn visit_sequence(&mut self, _: usize, children: Vec<usize>){
for child in children {
self.pred=Predicate::Nothing;
self.verify_multiple();
self.visit_expr(child);
}
}
fn visit_choice(&mut self, _: usize, children: Vec<usize>){
for child in children {
self.pred=Predicate::Nothing;
self.verify_multiple();
self.visit_expr(child);
}
}
}
|
extern crate coinjoin_analyzer;
use coinjoin_analyzer::{BlockFileIterator};
use std::env::args;
fn main() {
let mut num_outputs = 0u64;
let num_files = (args().len() - 1) as f64;
let mut current_file = 1f64;
for file in args().skip(1) {
let iter = match BlockFileIterator::open(file) {
Ok(i) => i,
Err(_) => panic!("Could not read file")
};
println!("{:.0}%", current_file / num_files * 100f64);
for block in iter {
for transaction in block.transactions.iter() {
for output in transaction.outputs.iter() {
if output.pk_script.len() > 0 {
num_outputs += 1
}
}
}
}
current_file += 1f64;
}
println!("There are {} outputs currently in the blockchain", num_outputs)
}
|
use crate::format_context::FormatContext;
use crate::order::{
filter_input::FilterInput, filter_output::FilterOutput, input::Input, input_kind::InputKind,
output::Output, output_kind::OutputKind, stream::Stream, Filter, Order, OutputResult::Entry,
ParameterValue,
};
use crate::probe::deep::{CheckParameterValue, FalseSceneResult, SceneResult, StreamProbeResult};
use crate::stream::Stream as ContextStream;
use ffmpeg_sys_next::AVMediaType;
use std::collections::HashMap;
pub fn create_graph<S: ::std::hash::BuildHasher>(
filename: &str,
video_indexes: Vec<u32>,
params: &HashMap<String, CheckParameterValue, S>,
) -> Result<Order, String> {
let mut filters = vec![];
let mut inputs = vec![];
let mut outputs = vec![];
for i in video_indexes {
let input_identifier = format!("video_input_{i}");
let output_identifier = format!("video_output_{i}");
let mut scdet_params: HashMap<String, ParameterValue> = HashMap::new();
if let Some(th) = params.get("threshold").and_then(|threshold| threshold.th) {
scdet_params.insert("threshold".to_string(), ParameterValue::Float(th));
}
let input_streams = vec![Stream {
index: i,
label: Some(input_identifier.clone()),
}];
filters.push(Filter {
name: "scdet".to_string(),
label: Some(format!("scdet_filter{i}")),
parameters: scdet_params,
inputs: Some(vec![FilterInput {
kind: InputKind::Stream,
stream_label: input_identifier,
}]),
outputs: Some(vec![FilterOutput {
stream_label: output_identifier.clone(),
}]),
});
inputs.push(Input::Streams {
id: i,
path: filename.to_string(),
streams: input_streams,
});
outputs.push(Output {
kind: Some(OutputKind::VideoMetadata),
keys: vec!["lavfi.scd.time".to_string(), "lavfi.scd.score".to_string()],
stream: Some(output_identifier),
path: None,
streams: vec![],
parameters: HashMap::new(),
});
}
Order::new(inputs, filters, outputs)
}
pub fn detect_scene<S: ::std::hash::BuildHasher>(
filename: &str,
streams: &mut [StreamProbeResult],
video_indexes: Vec<u32>,
params: HashMap<String, CheckParameterValue, S>,
) {
let mut order = create_graph(filename, video_indexes.clone(), ¶ms).unwrap();
if let Err(msg) = order.setup() {
error!("{:?}", msg);
return;
}
for index in video_indexes {
streams[index as usize].detected_scene = Some(vec![]);
streams[index as usize].detected_false_scene = Some(vec![]);
}
match order.process() {
Ok(results) => {
info!("END OF PROCESS");
info!("-> {:?} frames processed", results.len());
let mut frame_rate = 1.0;
let mut scene_count = 0;
let mut context = FormatContext::new(filename).unwrap();
if let Err(msg) = context.open_input() {
context.close_input();
error!("{:?}", msg);
return;
}
for index in 0..context.get_nb_streams() {
if let Ok(stream) = ContextStream::new(context.get_stream(index as isize)) {
if let AVMediaType::AVMEDIA_TYPE_VIDEO = context.get_stream_type(index as isize) {
frame_rate = stream.get_frame_rate().to_float();
}
}
}
for result in results {
if let Entry(entry_map) = result {
if let Some(stream_id) = entry_map.get("stream_id") {
let index: i32 = stream_id.parse().unwrap();
if streams[(index) as usize].detected_scene.is_none() {
error!("Error : unexpected detection on stream ${index}");
break;
}
let detected_scene = streams[(index) as usize].detected_scene.as_mut().unwrap();
let detected_false_scene = streams[(index) as usize]
.detected_false_scene
.as_mut()
.unwrap();
let mut scene = SceneResult {
frame_index: 0,
score: 0,
scene_number: 0,
};
let mut false_scene = FalseSceneResult { frame: 0 };
if let Some(value) = entry_map.get("lavfi.scd.time") {
scene.frame_index = (value.parse::<f32>().unwrap() * frame_rate) as i64;
if let Some(value) = entry_map.get("lavfi.scd.score") {
scene.score = (value.parse::<f32>().unwrap()) as i32;
}
if let Some(last_detect) = detected_scene.last() {
if scene.frame_index - last_detect.frame_index <= 1 {
false_scene.frame = scene.frame_index;
detected_false_scene.push(false_scene);
}
}
scene_count += 1;
scene.scene_number = scene_count;
detected_scene.push(scene);
}
}
}
}
}
Err(msg) => {
error!("ERROR: {}", msg);
}
}
}
|
mod builder;
mod keys;
pub mod operators;
pub mod seeds;
pub use operators::Operator;
pub type Vertex = Point3<f64>;
use builder::Builder;
use cgmath::{EuclideanSpace, InnerSpace, Point3, Vector3};
use fnv::FnvHashMap;
use keys::{FaceKey, VertexKey};
#[derive(Clone, Debug)]
pub struct Face {
indices: Vec<u32>,
}
impl Face {
pub fn indices(&self) -> &[u32] {
&self.indices
}
pub fn last(&self) -> (u32, u32) {
assert!(self.indices.len() > 1);
let last_index = self.indices.len() - 1;
(self.indices[last_index - 1], self.indices[last_index])
}
}
#[derive(Clone, Debug)]
pub struct Polyhedron {
vertices: Vec<Vertex>,
faces: Vec<Face>,
}
impl Polyhedron {
pub fn faces(&self) -> &[Face] {
&self.faces
}
pub fn vertices(&self) -> &[Vertex] {
&self.vertices
}
pub fn classify_faces(&self) -> Vec<usize> {
let mut face_classes = Vec::new();
let mut classes = FnvHashMap::default();
for face in &self.faces {
let sig = signature(self.face_vertices(face));
let new_index = classes.len();
let class = classes.entry(sig).or_insert(new_index);
face_classes.push(*class);
}
eprintln!("Face class count: {}", classes.len());
face_classes
}
pub fn face_vertices<'a>(
&'a self,
face: &'a Face,
) -> impl ExactSizeIterator<Item = Vertex> + 'a + Clone {
face.indices
.iter()
.map(move |index| -> Vertex { self.vertices[*index as usize] })
}
pub fn center_on_origin(&mut self) {
let mut center = Vector3 { x: 0.0, y: 0.0, z: 0.0 };
for vert in self.vertices.iter() {
center += vert.to_vec();
}
for vert in self.vertices.iter_mut() {
*vert -= center;
}
eprintln!("Recentered with adjustment of {:?}", center);
}
pub fn scale(&mut self, max_radius: f64) {
let mut furthest = Point3::origin();
let mut furthest_mag = 0.0;
for vert in self.vertices.iter() {
let mag = vert.to_vec().magnitude2();
if mag > furthest_mag {
furthest = *vert;
furthest_mag = mag;
}
}
let scale = max_radius / furthest.to_vec().magnitude();
for vert in self.vertices.iter_mut() {
*vert *= scale;
}
eprintln!("Scaled {}", scale);
}
/// Applies the operator and returns the resulting polyhedron.
pub fn apply(self, operator: Operator) -> Polyhedron {
use operators::*;
match operator {
Operator::Ambo => self.ambo(),
Operator::Dual => self.dual(),
Operator::Kis(kis) => self.kis(kis),
}
}
/// Applies each operator in order and returns the resulting polyhedron.
pub fn apply_iter(self, operators: impl IntoIterator<Item = Operator>) -> Polyhedron {
let mut polyhedron = self;
for op in operators.into_iter() {
polyhedron = polyhedron.apply(op);
}
polyhedron
}
/// Applies the `kis` operator and returns the resulting polyhedron.
pub fn kis(self, kis: operators::Kis) -> Polyhedron {
let mut builder = Builder::new();
for i in 0..self.vertices.len() {
let vertex = self.vertices[i];
builder.add_vertex(VertexKey::Seed(i as u32), vertex);
}
for face_index in 0..self.faces.len() {
let face = &self.faces[face_index];
let face_index = face_index as u32;
let is_identity =
kis.side_count() != 0 && kis.side_count() as usize != face.indices.len();
let mut v1_key = VertexKey::Seed(*face.indices.last().unwrap());
let apex_position = {
let vertices = self.face_vertices(face);
let center = center(vertices.clone());
let normal = normal(vertices.clone());
let dist_to_center = mean_distance(vertices.clone(), center);
center + normal * (kis.apex_scale() * dist_to_center)
};
for index in &face.indices {
let v2_key = VertexKey::Seed(*index);
if is_identity {
builder.add_flag(FaceKey::Seed(face_index), v1_key, v2_key);
v1_key = v2_key;
continue;
}
let apex_key = VertexKey::Centroid(face_index);
let face_key = FaceKey::PyramidFace(face_index, v1_key);
builder.add_vertex(apex_key, apex_position);
builder.add_flag(face_key, v1_key, v2_key);
builder.add_flag(face_key, v2_key, apex_key);
builder.add_flag(face_key, apex_key, v1_key);
v1_key = v2_key;
}
}
builder.build_polyhedron()
}
/// Applies the `dual` operator and returns the resulting polyhedron.
pub fn dual(self) -> Polyhedron {
let mut builder = Builder::new();
let mut face_map = Vec::with_capacity(self.vertices.len());
face_map.resize(face_map.capacity(), FnvHashMap::default());
for i in 0..self.faces.len() {
let center = center(self.face_vertices(&self.faces[i]));
builder.add_vertex(VertexKey::Centroid(i as u32), center);
}
for i in 0..self.faces.len() {
let face = &self.faces[i];
let mut v1 = face.last().1;
let face_vertex_key = VertexKey::Centroid(i as u32);
for v2 in &face.indices {
let map = &mut face_map[v1 as usize];
map.insert(*v2, face_vertex_key);
v1 = *v2;
}
}
for i in 0..self.faces.len() {
let face = &self.faces[i];
let mut v1 = face.last().1;
for v2 in &face.indices {
let map = &mut face_map[*v2 as usize];
let vertex = map.get(&v1).expect("Should be present");
builder.add_flag(FaceKey::Vertex(v1), *vertex, VertexKey::Centroid(i as u32));
v1 = *v2;
}
}
builder.build_polyhedron()
}
/// Applies the `ambo` operator and returns the resulting polyhedron.
pub fn ambo(self) -> Polyhedron {
let mut builder = Builder::new();
for i in 0..self.faces.len() {
let face = &self.faces[i];
let (mut v1, mut v2) = face.last();
for v3 in &face.indices {
if v1 < v2 {
let midpoint = self.vertices[v1 as usize].midpoint(self.vertices[v2 as usize]);
builder.add_vertex(VertexKey::midpoint(v1, v2), midpoint);
}
builder.add_flag(
FaceKey::Seed(i as u32),
VertexKey::midpoint(v1, v2),
VertexKey::midpoint(v2, *v3),
);
builder.add_flag(
FaceKey::Vertex(v2),
VertexKey::midpoint(v2, *v3),
VertexKey::midpoint(v1, v2),
);
v1 = v2;
v2 = *v3;
}
}
builder.build_polyhedron()
}
}
fn normal(mut vertices: impl Iterator<Item = Vertex>) -> Vector3<f64> {
// Using a vertex near the polygon reduces error for polygons far from the origin
let origin = Point3::origin();
let first = vertices.next().unwrap_or(origin);
let normalizer = first;
let mut normal = Vector3 {
x: 0.0,
y: 0.0,
z: 0.0,
};
let mut previous = first - normalizer;
for vertex in vertices {
let current = vertex - normalizer;
normal += previous.cross(current);
previous = current;
}
normal += previous.cross(first - normalizer);
normal.normalize()
}
fn center(vertices: impl Iterator<Item = Vertex>) -> Point3<f64> {
let mut center = Point3::<f64>::origin();
let mut count = 0u32;
for vertex in vertices {
center += vertex.to_vec();
count += 1;
}
center / count as f64
}
fn mean_distance(vertices: impl Iterator<Item = Vertex>, point: Point3<f64>) -> f64 {
use cgmath::MetricSpace;
let mut distance = 0.0;
let mut count = 0;
for vertex in vertices {
distance += point.distance(vertex);
count += 1;
}
distance / count as f64
}
fn signature(mut vertices: impl ExactSizeIterator<Item = Vertex>) -> Vec<u64> {
if vertices.len() < 3 {
return Vec::new();
}
let mut crosses = Vec::with_capacity(vertices.len());
let first = vertices.next().unwrap();
let second = vertices.next().unwrap();
let mut v1 = first;
let mut v2 = second;
for v3 in vertices {
crosses.push((v1 - v2).cross(v3 - v2).magnitude());
v1 = v2;
v2 = v3;
}
crosses.push((v1 - v2).cross(first - v2).magnitude());
crosses.push((v2 - first).cross(first - second).magnitude());
crosses.sort_unstable_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal));
crosses
.into_iter()
.map(|f| -> u64 { truncate_mantissa(f, 7) })
.collect()
}
fn truncate_mantissa(f: f64, bits: u32) -> u64 {
use cgmath::num_traits::Float;
const ZERO_COUNT: u32 = 0u64.leading_zeros();
if bits >= ZERO_COUNT {
panic!("bits must be less than {}.", ZERO_COUNT);
}
let (mantissa, _, _) = f.integer_decode();
let original_bits = ZERO_COUNT - mantissa.leading_zeros();
if bits >= original_bits {
// The mantissa has the same or fewer significant bits than we want already,
// so we can just return it outright.
return mantissa;
}
// Truncate until we have the number of bits we want
let shift = original_bits - bits;
mantissa >> shift
}
|
extern crate eui48;
use std::io::prelude::*;
use self::eui48::MacAddress;
use types::{FromSql, ToSql, Type, IsNull, SessionInfo};
use Result;
impl FromSql for MacAddress {
fn from_sql<R: Read>(_: &Type, raw: &mut R, _: &SessionInfo) -> Result<MacAddress> {
let mut bytes = [0; 6];
try!(raw.read_exact(&mut bytes));
Ok(MacAddress::new(bytes))
}
accepts!(Type::Macaddr);
}
impl ToSql for MacAddress {
fn to_sql<W: Write + ?Sized>(&self, _: &Type, w: &mut W, _: &SessionInfo) -> Result<IsNull> {
try!(w.write_all(self.as_bytes()));
Ok(IsNull::No)
}
accepts!(Type::Macaddr);
to_sql_checked!();
}
|
use crate::cst;
use crate::cst::ExprKind;
use rowan::TextRange;
use std::rc::Rc;
#[derive(Clone, Eq, PartialEq, Debug)]
pub enum Ty {
Int {
range: TextRange,
},
Bool {
range: TextRange,
},
Func {
range: TextRange,
arg: Rc<Ty>,
result: Rc<Ty>,
},
Forall {
range: TextRange,
binding: Binding,
ty: Rc<Ty>,
},
Var {
range: TextRange,
ident: String,
},
Unknown {
range: TextRange,
unknown: u32,
},
}
#[derive(Clone, Eq, PartialEq, Debug)]
pub struct Binding {
range: TextRange,
ty: Rc<Ty>,
ident: String,
}
#[derive(Clone, Eq, PartialEq, Debug)]
pub enum Expr {
Var {
ty: Rc<Ty>,
range: TextRange,
ident: String,
},
Lambda {
ty: Rc<Ty>,
range: TextRange,
binder: Binding,
body: Rc<Expr>,
},
App {
ty: Rc<Ty>,
range: TextRange,
func: Rc<Expr>,
arg: Rc<Expr>,
},
Lit {
ty: Rc<Ty>,
range: TextRange,
lit: Lit,
},
TyApp {
ty: Rc<Ty>,
range: TextRange,
func: Rc<Expr>,
arg: Rc<Ty>,
},
TyLambda {
ty: Rc<Ty>,
range: TextRange,
binder: (TextRange, String),
body: Rc<Expr>,
},
}
#[derive(Clone, Eq, PartialEq, Debug)]
pub enum Lit {
Int(i32),
Bool(bool),
}
fn var(range: TextRange, ident: String) -> Expr {
Expr::Var {
ty: Rc::new(Ty::Unknown {
range,
unknown: 0,
}),
range,
ident
}
}
impl Expr {
// pub fn from_cst(cst: cst::Expr) -> Option<Self> {
// match cst.kind() {
// ExprKind::Var(v) => Some(var(v.0.text_range(), v.name())),
// ExprKind::Lambda(lambda) => {
// let binder = lambda.binder()?;
// let body = lambda.body()?;
// let body = Self::from_cst(body)?;
// Some(Expr::Lambda(binder, Rc::new(body)))
// }
// ExprKind::Application(app) => {
// let func = Self::from_cst(app.func())?;
// let arg = Self::from_cst(app.arg())?;
// Some(Expr::App(Rc::new(func), Rc::new(arg)))
// }
// ExprKind::IntLit(int) => Some(Expr::IntLit(int.value())),
// ExprKind::BooleanLit(bool) => Some(Expr::BoolLit(bool.value())),
// }
// }
}
|
#[doc = "Reader of register NVIC_IPR3"]
pub type R = crate::R<u32, super::NVIC_IPR3>;
#[doc = "Writer for register NVIC_IPR3"]
pub type W = crate::W<u32, super::NVIC_IPR3>;
#[doc = "Register NVIC_IPR3 `reset()`'s with value 0"]
impl crate::ResetValue for super::NVIC_IPR3 {
type Type = u32;
#[inline(always)]
fn reset_value() -> Self::Type {
0
}
}
#[doc = "Reader of field `IP_15`"]
pub type IP_15_R = crate::R<u8, u8>;
#[doc = "Write proxy for field `IP_15`"]
pub struct IP_15_W<'a> {
w: &'a mut W,
}
impl<'a> IP_15_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x03 << 30)) | (((value as u32) & 0x03) << 30);
self.w
}
}
#[doc = "Reader of field `IP_14`"]
pub type IP_14_R = crate::R<u8, u8>;
#[doc = "Write proxy for field `IP_14`"]
pub struct IP_14_W<'a> {
w: &'a mut W,
}
impl<'a> IP_14_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x03 << 22)) | (((value as u32) & 0x03) << 22);
self.w
}
}
#[doc = "Reader of field `IP_13`"]
pub type IP_13_R = crate::R<u8, u8>;
#[doc = "Write proxy for field `IP_13`"]
pub struct IP_13_W<'a> {
w: &'a mut W,
}
impl<'a> IP_13_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x03 << 14)) | (((value as u32) & 0x03) << 14);
self.w
}
}
#[doc = "Reader of field `IP_12`"]
pub type IP_12_R = crate::R<u8, u8>;
#[doc = "Write proxy for field `IP_12`"]
pub struct IP_12_W<'a> {
w: &'a mut W,
}
impl<'a> IP_12_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x03 << 6)) | (((value as u32) & 0x03) << 6);
self.w
}
}
impl R {
#[doc = "Bits 30:31 - Priority of interrupt 15"]
#[inline(always)]
pub fn ip_15(&self) -> IP_15_R {
IP_15_R::new(((self.bits >> 30) & 0x03) as u8)
}
#[doc = "Bits 22:23 - Priority of interrupt 14"]
#[inline(always)]
pub fn ip_14(&self) -> IP_14_R {
IP_14_R::new(((self.bits >> 22) & 0x03) as u8)
}
#[doc = "Bits 14:15 - Priority of interrupt 13"]
#[inline(always)]
pub fn ip_13(&self) -> IP_13_R {
IP_13_R::new(((self.bits >> 14) & 0x03) as u8)
}
#[doc = "Bits 6:7 - Priority of interrupt 12"]
#[inline(always)]
pub fn ip_12(&self) -> IP_12_R {
IP_12_R::new(((self.bits >> 6) & 0x03) as u8)
}
}
impl W {
#[doc = "Bits 30:31 - Priority of interrupt 15"]
#[inline(always)]
pub fn ip_15(&mut self) -> IP_15_W {
IP_15_W { w: self }
}
#[doc = "Bits 22:23 - Priority of interrupt 14"]
#[inline(always)]
pub fn ip_14(&mut self) -> IP_14_W {
IP_14_W { w: self }
}
#[doc = "Bits 14:15 - Priority of interrupt 13"]
#[inline(always)]
pub fn ip_13(&mut self) -> IP_13_W {
IP_13_W { w: self }
}
#[doc = "Bits 6:7 - Priority of interrupt 12"]
#[inline(always)]
pub fn ip_12(&mut self) -> IP_12_W {
IP_12_W { w: self }
}
}
|
// For details on LoRa parameters, see Semtech SX1276/77/78/79 Datasheet.
// For understanding how the `Radio` capsule is architected around the `SpiMasterDevice`, see similiar implementation for the RF233.
use core::cell::Cell;
use kernel::common::cells::TakeCell;
use kernel::debug_gpio;
use kernel::hil::gpio;
use kernel::hil::lora::{PacketConfig, RadioConfig, RadioData};
use kernel::hil::radio;
use kernel::hil::spi;
use kernel::hil::spi::{SpiMasterClient, SpiMasterDevice};
use kernel::ReturnCode;
// not written to registers unlike Modes
// only help in programming for SPI layer ops
#[derive(Copy, Clone, PartialEq)]
enum InternalState {
TxOn,
RxOn,
Sleep,
Ready,
}
// registers
pub enum RegMap {
RegFifo = 0x00,
RegOpMode = 0x01,
RegFrfMsb = 0x06,
RegFrfMid = 0x07,
RegFrfLsb = 0x08,
RegPaConfig = 0x09,
RegOcp = 0x0b,
RegLna = 0x0c,
RegFifoAddrPtr = 0x0d,
RegFifoTxBaseAddr = 0x0e,
RegFifoRxBaseAddr = 0x0f,
RegFifoRxCurrentAddr = 0x10,
RegIrqFlags = 0x12,
RegRxNbBytes = 0x13,
RegPktSnrValue = 0x19,
RegPktRssiValue = 0x1a,
RegModemConfig1 = 0x1d,
RegModemConfig2 = 0x1e,
RegPreambleMsb = 0x20,
RegPreambleLsb = 0x21,
RegPayloadLength = 0x22,
RegModemConfig3 = 0x26,
RegFreqErrorMsb = 0x28,
RegFreqErrorMid = 0x29,
RegFreqErrorLsb = 0x2a,
RegRssiWideband = 0x2c,
RegDetectionOptimize = 0x31,
RegInvertiq = 0x33,
RegDetectionThreshold = 0x37,
RegSyncWord = 0x39,
RegInvertiq2 = 0x3b,
RegDioMapping1 = 0x40,
RegVersion = 0x42,
RegPaDac = 0x4d,
}
// modes
enum Mode {
ModeLongRangeMode = 0x80,
ModeSleep = 0x00,
ModeStdby = 0x01,
ModeTx = 0x03,
ModeRxContinuous = 0x05,
ModeRxSingle = 0x06,
}
// Irq masks
enum Irq {
IrqTxDoneMask = 0x08,
IrqPayloadCrcErrorMask = 0x20,
IrqRxDoneMask = 0x40,
}
// Other config
const PA_BOOST: u8 = 0x80;
const MAX_PKT_LENGTH: u8 = 255;
// The modem
pub struct Radio<'a> {
spi: &'a dyn SpiMasterDevice,
spi_buf: TakeCell<'static, [u8]>,
spi_rx: TakeCell<'static, [u8]>,
spi_tx: TakeCell<'static, [u8]>,
spi_busy: Cell<bool>,
//Pins
//cs_pin: &'a dyn gpio::Pin,
reset_pin: &'a dyn gpio::Pin,
//irq_pin: &'a dyn gpio::InterruptPin,
//State params
sleep_pending: Cell<bool>,
wake_pending: Cell<bool>,
interrupt_handling: Cell<bool>,
interrupt_pending: Cell<bool>,
state: Cell<InternalState>,
//LoRa params
frequency: Cell<u64>,
packet_index: Cell<u8>,
implicit_header: Cell<bool>,
tx_done: bool,
rx_done: bool,
}
//
// SPI functions
// Implementing a public trait to cleanly pass to board. TO DO: move to kernel/hil
// Note: initialize, start, stop are specific to SPI
//
impl RadioConfig for Radio<'_> {
fn initialize(
&self,
buf: &'static mut [u8],
reg_write: &'static mut [u8],
reg_read: &'static mut [u8],
) -> ReturnCode {
if buf.len() < radio::MAX_BUF_SIZE || reg_read.len() != 2 || reg_write.len() != 2 {
return ReturnCode::ESIZE;
}
self.spi_buf.replace(buf);
self.spi_rx.replace(reg_read);
self.spi_tx.replace(reg_write);
ReturnCode::SUCCESS
}
fn reset(&self) -> ReturnCode {
self.spi.configure(
spi::ClockPolarity::IdleLow,
spi::ClockPhase::SampleLeading,
100000,
);
self.reset_pin.make_output();
for _i in 0..10000 {
self.reset_pin.clear();
}
self.reset_pin.set();
ReturnCode::SUCCESS
}
fn start(&self) -> ReturnCode {
self.set_frequency(self.frequency);
// set base addresses
self.register_write(RegMap::RegFifoTxBaseAddr, 0);
self.register_write(RegMap::RegFifoRxBaseAddr, 0);
// set Lna boost
self.register_write(
RegMap::RegLna,
self.register_return(RegMap::RegLna) as u8 | 0x03,
);
// set auto Agc
self.register_write(RegMap::RegModemConfig3, 0x04);
// set output power to 17 dBm
self.set_power(17, 0);
ReturnCode::SUCCESS
}
fn stop(&self) -> ReturnCode {
// TODO fix
// let version = self.register_return(RegMap::RegVersion) as u8;
// if version != 0x12 {
// return ReturnCode::FAIL;
// }
self.sleep();
if self.state.get() != InternalState::Sleep {
return ReturnCode::EALREADY;
}
self.ready();
ReturnCode::SUCCESS
}
//
// State functions
//
fn ready(&self) -> ReturnCode {
self.register_write(
RegMap::RegOpMode,
Mode::ModeLongRangeMode as u8 | Mode::ModeStdby as u8,
);
if self.state.get() == InternalState::Sleep {
self.state.set(InternalState::Ready);
} else {
// Delay wakeup until the radio turns all the way off
self.wake_pending.set(true);
}
ReturnCode::SUCCESS
}
fn sleep(&self) -> ReturnCode {
self.register_write(
RegMap::RegOpMode,
Mode::ModeLongRangeMode as u8 | Mode::ModeSleep as u8,
);
self.sleep_pending.set(false);
ReturnCode::SUCCESS
}
fn set_header_mode(&self, implicit: bool) {
let cfg: u8;
if implicit {
cfg = self.register_return(RegMap::RegModemConfig1) as u8 | 0x01;
} else {
cfg = self.register_return(RegMap::RegModemConfig1) as u8 & 0xfe;
}
self.register_write(RegMap::RegModemConfig1, cfg);
self.implicit_header.set(false);
}
fn is_on(&self) -> bool {
if (self.register_return(RegMap::RegOpMode) & Mode::ModeTx as u8) == Mode::ModeTx as u8 {
return true;
}
if (self.register_return(RegMap::RegIrqFlags) & Irq::IrqTxDoneMask as u8) != 0 {
// clear Irq's
self.register_write(RegMap::RegIrqFlags, Irq::IrqTxDoneMask as u8);
}
return false;
}
// Radio operations for handling LoRa IRQ
fn handle_packet_irq(&self) -> ReturnCode {
let irq_flags = self.register_return(RegMap::RegIrqFlags) as u8;
// clear Irq's
self.register_write(RegMap::RegIrqFlags, irq_flags);
if (irq_flags & Irq::IrqPayloadCrcErrorMask as u8) == 0 {
if (irq_flags & Irq::IrqRxDoneMask as u8) != 0 {
// received a packet
self.packet_index.set(0);
// read packet length
let packet_length;
if self.implicit_header.get() == true {
packet_length = self.register_return(RegMap::RegPayloadLength) as u8;
} else {
packet_length = self.register_return(RegMap::RegRxNbBytes) as u8;
}
// set Fifo address to current Rx address
self.register_write(
RegMap::RegFifoAddrPtr,
self.register_return(RegMap::RegFifoRxCurrentAddr),
);
if self.rx_done && packet_length != 0 {
self.handle_interrupt();
}
// reset Fifo address
self.register_write(RegMap::RegFifoAddrPtr, 0);
} else if (irq_flags & Irq::IrqTxDoneMask as u8) != 0 {
if self.tx_done {
self.handle_interrupt();
}
}
}
ReturnCode::SUCCESS
}
}
//
// SPI functions
// Implementing a public trait to cleanly pass to board. TO DO: move to kernel/hil
// Note: initialize, start, stop are specific to SPI
//
impl RadioData for Radio<'_> {
fn transmit(&self, implicit: bool) -> ReturnCode {
if self.is_on() {
return ReturnCode::FAIL;
}
self.ready();
self.set_header_mode(implicit);
self.register_write(RegMap::RegFifoAddrPtr, 0);
self.register_write(RegMap::RegPayloadLength, 0);
ReturnCode::SUCCESS
}
fn transmit_done(&self, asyn: bool) -> ReturnCode {
if (asyn) && (self.tx_done) {
self.register_write(RegMap::RegDioMapping1, 0x40);
}
// put in Tx mode
self.register_write(
RegMap::RegOpMode,
Mode::ModeLongRangeMode as u8 | Mode::ModeTx as u8,
);
if !asyn {
// wait for Tx done
while self.register_return(RegMap::RegIrqFlags) & (Irq::IrqTxDoneMask as u8) == 0 {}
// clear Irq's
self.register_write(RegMap::RegIrqFlags, Irq::IrqTxDoneMask as u8);
}
ReturnCode::SUCCESS
}
fn receive(&self, size: u8) {
self.register_write(RegMap::RegDioMapping1, 0x00);
if size > 0 {
self.set_header_mode(true);
self.register_write(RegMap::RegPayloadLength, size & 0xff);
} else {
self.set_header_mode(false);
}
self.register_write(
RegMap::RegOpMode,
Mode::ModeLongRangeMode as u8 | Mode::ModeRxContinuous as u8,
);
}
fn receive_done(&self, size: usize) -> u8 {
let mut packet_length = 0 as u8;
let irq_flags = self.register_return(RegMap::RegIrqFlags) as u8;
if size > 0 {
self.set_header_mode(true);
self.register_write(RegMap::RegPayloadLength, size as u8 & 0xff);
} else {
self.set_header_mode(false);
}
// clear Irq's
self.register_write(RegMap::RegIrqFlags, irq_flags);
if (irq_flags & Irq::IrqRxDoneMask as u8 != 0)
&& (irq_flags & Irq::IrqPayloadCrcErrorMask as u8 != 0)
{
// received a packet
self.packet_index.set(0);
// read packet length
if self.implicit_header.get() == true {
packet_length = self.register_return(RegMap::RegPayloadLength) as u8;
} else {
packet_length = self.register_return(RegMap::RegRxNbBytes) as u8;
}
// set Fifo address to current Rx address
self.register_write(
RegMap::RegFifoAddrPtr,
self.register_return(RegMap::RegFifoRxCurrentAddr),
);
self.ready();
} else if self.register_return(RegMap::RegOpMode)
!= (Mode::ModeLongRangeMode as u8 | Mode::ModeRxSingle as u8)
{
// not currently in Rx mode
// reset Fifo address
self.register_write(RegMap::RegFifoAddrPtr, 0);
// put in single Rx mode
self.register_write(
RegMap::RegOpMode,
Mode::ModeLongRangeMode as u8 | Mode::ModeRxSingle as u8,
);
}
return packet_length;
}
// manipulate FIFO
fn read(&self) -> u8 {
self.packet_index.set(self.packet_index.get() + 1);
self.register_return(RegMap::RegFifo)
}
fn write(&self, buf: &[u8], mut size: u8) {
let current_length = self.register_return(RegMap::RegPayloadLength) as u8;
// check size
if (current_length + size) > MAX_PKT_LENGTH {
size = MAX_PKT_LENGTH - current_length;
}
// write data
for i in 0..size {
self.register_write(RegMap::RegFifo, buf[i as usize]);
}
// update length
self.register_write(RegMap::RegPayloadLength, current_length + size);
}
}
impl<'a> Radio<'a> {
fn new(
spi: &'a dyn SpiMasterDevice,
//cs: &'a dyn gpio::Pin,
reset: &'a dyn gpio::Pin,
//irq: &'a dyn gpio::InterruptPin,
) -> Radio<'a> {
Radio {
spi: spi,
spi_buf: TakeCell::empty(),
spi_rx: TakeCell::empty(),
spi_tx: TakeCell::empty(),
spi_busy: Cell::new(false),
//cs_pin: cs,
reset_pin: reset,
//irq_pin: irq,
sleep_pending: Cell::new(false),
wake_pending: Cell::new(false),
interrupt_handling: Cell::new(false),
interrupt_pending: Cell::new(false),
state: Cell::new(InternalState::Sleep),
frequency: Cell::new(0),
packet_index: Cell::new(0),
implicit_header: Cell::new(false),
tx_done: false,
rx_done: false,
}
}
// SPI operations for handling LoRa IRQ
fn handle_interrupt(&self) {
if self.spi_busy.get() == false {
// Need to disable reception until we've completed read
if self.state.get() != InternalState::RxOn {
self.interrupt_handling.set(true);
}
} else {
self.interrupt_pending.set(true);
}
}
fn register_write(&self, reg: RegMap, val: u8) -> ReturnCode {
if self.spi_busy.get() || self.spi_tx.is_none() || self.spi_rx.is_none() {
return ReturnCode::EBUSY;
}
let wbuf = self.spi_tx.take().unwrap();
let rbuf = self.spi_rx.take().unwrap();
wbuf[0] = (reg as u8) | 0x80;
wbuf[1] = val;
self.spi.read_write_bytes(wbuf, Some(rbuf), 2);
self.spi_busy.set(true);
ReturnCode::SUCCESS
}
fn register_read(&self, reg: RegMap) -> ReturnCode {
if self.spi_busy.get() || self.spi_tx.is_none() || self.spi_rx.is_none() {
return ReturnCode::EBUSY;
}
let wbuf = self.spi_tx.take().unwrap();
let rbuf = self.spi_rx.take().unwrap();
wbuf[0] = (reg as u8) | 0x7f;
wbuf[1] = 0;
self.spi.read_write_bytes(wbuf, Some(rbuf), 2);
self.spi_busy.set(true);
ReturnCode::SUCCESS
}
fn register_return(&self, reg: RegMap) -> u8 {
if self.register_read(reg) == ReturnCode::SUCCESS {
self.spi_rx.take().unwrap()[1] as u8
} else {
return 0;
}
}
fn state_transition_write(&self, reg: RegMap, val: u8, state: InternalState) {
self.state.set(state);
self.register_write(reg, val);
}
fn state_transition_read(&self, reg: RegMap, state: InternalState) {
self.state.set(state);
self.register_read(reg);
}
}
// TODO make transmit_done sync
impl SpiMasterClient for Radio<'_> {
fn read_write_done(
&self,
_write: &'static mut [u8],
_read: Option<&'static mut [u8]>,
_len: usize,
) {
self.spi_busy.set(false);
let rbuf = _read.take().unwrap();
let status = rbuf[0] & 0x1f;
let result = rbuf[1];
// Need to put buffers back. Four cases:
// 1. a frame read completed, need to put RX buf back and put the
// used write buf back into spi_buf
// 2. a frame length read completed, need to put RX buf back and
// put the used write buf back into spi_buf
// 3. a frame write completed, need to put TX buf back and put the
// used read buf back into spi_buf
// 4. a register op completed, need to but the used read buf back into
// spi_rx and the used write buf into spi_tx. interrupt handling
// is implicitly a register op.
// Note that in cases 1-3, we need to enact a state transition
// so that, if an interrupt is pending, we don't put the buffers
// back again. The _DONE states denote that the frame transfer
// has completed. So we'll put the buffers back only once.
let state = self.state.get();
let handling = self.interrupt_handling.get();
if !handling && state == InternalState::RxOn {
self.spi_buf.replace(_write);
self.spi_rx.replace(rbuf);
self.receive_done(_len);
self.rx_done = true;
} else if !handling && state == InternalState::TxOn {
self.spi_buf.replace(_write);
self.spi_rx.replace(rbuf);
self.transmit_done(true);
self.tx_done = true;
} else {
self.spi_rx.replace(rbuf);
self.spi_tx.replace(_write);
}
if self.interrupt_pending.get() && state == InternalState::Sleep {
self.interrupt_pending.set(false);
self.handle_interrupt();
return;
}
if state == InternalState::Ready {
self.wake_pending.set(false);
if self.sleep_pending.get() {
self.sleep_pending.set(false);
}
}
}
}
|
pub struct Plane {
seats: Vec<Seat>,
}
impl Plane {
const MAX_SEATS: u32 = 128 * 8;
pub fn new(boardingpasses: &str) -> Plane {
Self {
seats: Plane::parse_boardingpasses(boardingpasses),
}
}
fn parse_boardingpasses(input: &str) -> Vec<Seat> {
let mut seats: Vec<Seat> = Vec::new();
for line in input.lines() {
seats.push(Seat::new(line));
}
seats
}
pub fn get_highest_seat_id(&self) -> u32 {
let mut highest_id: u32 = 0;
for seat in &self.seats {
if seat.id > highest_id {
highest_id = seat.id;
}
}
highest_id
}
pub fn get_my_seat_id(&self) -> Option<u32> {
let mut my_seat_id = None;
for seat_id in 1..Plane::MAX_SEATS-1 {
if !self.seat_occupied(seat_id) {
// empty seat
println!("seat {} is empty", seat_id);
// checks if id -1 and +1 are present
if self.seat_occupied(seat_id-1) && self.seat_occupied(seat_id+1) {
println!("Thats my seat!");
my_seat_id = Some(seat_id);
break;
}
}
}
my_seat_id
}
pub fn seat_occupied(&self, seat_id: u32) -> bool {
self.seats.iter().any(|s| s.id == seat_id)
}
}
struct Seat {
pos: (u32, u32), // (row, col)
id: u32,
}
impl Seat {
pub fn new(input: &str) -> Seat {
let pos = Seat::get_pos(input);
let id = Seat::get_id(pos);
// println!("Boarding pass {} has pos {:?} and id {}", input, pos, id);
Self {
pos,
id,
}
}
fn get_pos(input: &str) -> (u32, u32) {
let row_chars = input[0..7]
.replace("F", "0")
.replace("B", "1");
let row = u32::from_str_radix(&row_chars, 2).unwrap();
let col_chars = input[7..10]
.replace("L", "0")
.replace("R", "1");
let col = u32::from_str_radix(&col_chars, 2).unwrap();
(row, col)
}
fn get_id(pos: (u32, u32)) -> u32 {
pos.0 * 8 + pos.1
}
} |
use id::ID;
use qdf::state::State;
/// Holds information about space level.
#[derive(Debug, Clone)]
pub struct Level<S>
where
S: State,
{
id: ID,
parent: Option<ID>,
level: usize,
index: usize,
state: S,
sublevels: Vec<ID>,
}
impl<S> Level<S>
where
S: State,
{
#[inline]
pub(crate) fn new(id: ID, parent: Option<ID>, level: usize, index: usize, state: S) -> Self {
Self {
id,
parent,
level,
index,
state,
sublevels: vec![],
}
}
/// Gets level id.
#[inline]
pub fn id(&self) -> ID {
self.id
}
/// Gets level parent id or `None` if it is root level.
#[inline]
pub fn parent(&self) -> Option<ID> {
self.parent
}
/// Gets zoom level index.
#[inline]
pub fn level(&self) -> usize {
self.level
}
/// Tells level index in parent.
#[inline]
pub fn index(&self) -> usize {
self.index
}
/// Gets level state.
#[inline]
pub fn state(&self) -> &S {
&self.state
}
/// Gets level sublevels.
#[inline]
pub fn sublevels(&self) -> &[ID] {
&self.sublevels
}
#[inline]
pub fn apply_state(&mut self, state: S) {
self.state = state;
}
#[inline]
pub(crate) fn apply_sublevels(&mut self, sublevels: Vec<ID>) {
self.sublevels = sublevels;
}
}
|
use perseus::{is_server, t, Template};
use std::rc::Rc;
use sycamore::prelude::{component, template, GenericNode, Template as SycamoreTemplate};
#[component(AboutPage<G>)]
pub fn about_page() -> SycamoreTemplate<G> {
template! {
p { (t!("about")) }
p {
(
if is_server!() {
"This is running on the server."
} else {
"This is running on the client."
}
)
}
}
}
pub fn get_template<G: GenericNode>() -> Template<G> {
Template::new("about").template(Rc::new(|_| {
template! {
AboutPage()
}
}))
}
|
//! Bindings to [LAPACK] \(Fortran).
//!
//! The usage of the package is explained [here][usage].
//!
//! [lapack]: https://en.wikipedia.org/wiki/LAPACK
//! [usage]: https://blas-lapack-rs.github.io/usage
#![allow(non_camel_case_types)]
#![no_std]
// extern crate libc;
// use libc::{c_char, c_double, c_float, c_int};
pub type c_char = i8;
pub type c_double = f64;
pub type c_float = f32;
pub type c_int = i32;
/// A complex number with 64-bit parts.
#[allow(bad_style)]
pub type c_double_complex = [c_double; 2];
/// A complex number with 32-bit parts.
#[allow(bad_style)]
pub type c_float_complex = [c_float; 2];
pub type lapack_complex_double = c_double_complex;
pub type lapack_complex_float = c_float_complex;
pub type lapack_int = c_int;
pub type lapack_logical = lapack_int;
pub type LAPACK_S_SELECT2 = Option<extern "C" fn(*const c_float, *const c_float) -> lapack_logical>;
pub type LAPACK_S_SELECT3 = Option<
extern "C" fn(*const c_float, *const c_float, *const c_float)
-> lapack_logical,
>;
pub type LAPACK_D_SELECT2 = Option<
extern "C" fn(*const c_double, *const c_double) -> lapack_logical,
>;
pub type LAPACK_D_SELECT3 = Option<
extern "C" fn(*const c_double, *const c_double, *const c_double)
-> lapack_logical,
>;
pub type LAPACK_C_SELECT1 = Option<extern "C" fn(*const lapack_complex_float) -> lapack_logical>;
pub type LAPACK_C_SELECT2 = Option<
extern "C" fn(*const lapack_complex_float, *const lapack_complex_float)
-> lapack_logical,
>;
pub type LAPACK_Z_SELECT1 = Option<extern "C" fn(*const lapack_complex_double) -> lapack_logical>;
pub type LAPACK_Z_SELECT2 = Option<
extern "C" fn(*const lapack_complex_double, *const lapack_complex_double)
-> lapack_logical,
>;
extern "C" {
pub fn sgetrf_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
ipiv: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dgetrf_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
ipiv: *mut lapack_int,
info: *mut lapack_int,
);
pub fn cgetrf_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
ipiv: *mut lapack_int,
info: *mut lapack_int,
);
pub fn zgetrf_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
ipiv: *mut lapack_int,
info: *mut lapack_int,
);
pub fn sgetrf2_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
ipiv: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dgetrf2_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
ipiv: *mut lapack_int,
info: *mut lapack_int,
);
pub fn cgetrf2_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
ipiv: *mut lapack_int,
info: *mut lapack_int,
);
pub fn zgetrf2_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
ipiv: *mut lapack_int,
info: *mut lapack_int,
);
pub fn sgbtrf_(
m: *const lapack_int,
n: *const lapack_int,
kl: *const lapack_int,
ku: *const lapack_int,
ab: *mut c_float,
ldab: *const lapack_int,
ipiv: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dgbtrf_(
m: *const lapack_int,
n: *const lapack_int,
kl: *const lapack_int,
ku: *const lapack_int,
ab: *mut c_double,
ldab: *const lapack_int,
ipiv: *mut lapack_int,
info: *mut lapack_int,
);
pub fn cgbtrf_(
m: *const lapack_int,
n: *const lapack_int,
kl: *const lapack_int,
ku: *const lapack_int,
ab: *mut lapack_complex_float,
ldab: *const lapack_int,
ipiv: *mut lapack_int,
info: *mut lapack_int,
);
pub fn zgbtrf_(
m: *const lapack_int,
n: *const lapack_int,
kl: *const lapack_int,
ku: *const lapack_int,
ab: *mut lapack_complex_double,
ldab: *const lapack_int,
ipiv: *mut lapack_int,
info: *mut lapack_int,
);
pub fn sgttrf_(
n: *const lapack_int,
dl: *mut c_float,
d: *mut c_float,
du: *mut c_float,
du2: *mut c_float,
ipiv: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dgttrf_(
n: *const lapack_int,
dl: *mut c_double,
d: *mut c_double,
du: *mut c_double,
du2: *mut c_double,
ipiv: *mut lapack_int,
info: *mut lapack_int,
);
pub fn cgttrf_(
n: *const lapack_int,
dl: *mut lapack_complex_float,
d: *mut lapack_complex_float,
du: *mut lapack_complex_float,
du2: *mut lapack_complex_float,
ipiv: *mut lapack_int,
info: *mut lapack_int,
);
pub fn zgttrf_(
n: *const lapack_int,
dl: *mut lapack_complex_double,
d: *mut lapack_complex_double,
du: *mut lapack_complex_double,
du2: *mut lapack_complex_double,
ipiv: *mut lapack_int,
info: *mut lapack_int,
);
pub fn spotrf2_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
info: *mut lapack_int,
);
pub fn dpotrf2_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
info: *mut lapack_int,
);
pub fn cpotrf2_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
info: *mut lapack_int,
);
pub fn zpotrf2_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
info: *mut lapack_int,
);
pub fn spotrf_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
info: *mut lapack_int,
);
pub fn dpotrf_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
info: *mut lapack_int,
);
pub fn cpotrf_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
info: *mut lapack_int,
);
pub fn zpotrf_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
info: *mut lapack_int,
);
pub fn dpstrf_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
piv: *mut lapack_int,
rank: *mut lapack_int,
tol: *const c_double,
work: *mut c_double,
info: *mut lapack_int,
);
pub fn spstrf_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
piv: *mut lapack_int,
rank: *mut lapack_int,
tol: *const c_float,
work: *mut c_float,
info: *mut lapack_int,
);
pub fn zpstrf_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
piv: *mut lapack_int,
rank: *mut lapack_int,
tol: *const c_double,
work: *mut c_double,
info: *mut lapack_int,
);
pub fn cpstrf_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
piv: *mut lapack_int,
rank: *mut lapack_int,
tol: *const c_float,
work: *mut c_float,
info: *mut lapack_int,
);
pub fn dpftrf_(
transr: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
a: *mut c_double,
info: *mut lapack_int,
);
pub fn spftrf_(
transr: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
a: *mut c_float,
info: *mut lapack_int,
);
pub fn zpftrf_(
transr: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_double,
info: *mut lapack_int,
);
pub fn cpftrf_(
transr: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_float,
info: *mut lapack_int,
);
pub fn spptrf_(
uplo: *const c_char,
n: *const lapack_int,
ap: *mut c_float,
info: *mut lapack_int,
);
pub fn dpptrf_(
uplo: *const c_char,
n: *const lapack_int,
ap: *mut c_double,
info: *mut lapack_int,
);
pub fn cpptrf_(
uplo: *const c_char,
n: *const lapack_int,
ap: *mut lapack_complex_float,
info: *mut lapack_int,
);
pub fn zpptrf_(
uplo: *const c_char,
n: *const lapack_int,
ap: *mut lapack_complex_double,
info: *mut lapack_int,
);
pub fn spbtrf_(
uplo: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
ab: *mut c_float,
ldab: *const lapack_int,
info: *mut lapack_int,
);
pub fn dpbtrf_(
uplo: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
ab: *mut c_double,
ldab: *const lapack_int,
info: *mut lapack_int,
);
pub fn cpbtrf_(
uplo: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
ab: *mut lapack_complex_float,
ldab: *const lapack_int,
info: *mut lapack_int,
);
pub fn zpbtrf_(
uplo: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
ab: *mut lapack_complex_double,
ldab: *const lapack_int,
info: *mut lapack_int,
);
pub fn spttrf_(n: *const lapack_int, d: *mut c_float, e: *mut c_float, info: *mut lapack_int);
pub fn dpttrf_(n: *const lapack_int, d: *mut c_double, e: *mut c_double, info: *mut lapack_int);
pub fn cpttrf_(
n: *const lapack_int,
d: *mut c_float,
e: *mut lapack_complex_float,
info: *mut lapack_int,
);
pub fn zpttrf_(
n: *const lapack_int,
d: *mut c_double,
e: *mut lapack_complex_double,
info: *mut lapack_int,
);
pub fn ssytrf_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
ipiv: *mut lapack_int,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dsytrf_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
ipiv: *mut lapack_int,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn csytrf_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
ipiv: *mut lapack_int,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zsytrf_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
ipiv: *mut lapack_int,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn chetrf_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
ipiv: *mut lapack_int,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zhetrf_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
ipiv: *mut lapack_int,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn ssptrf_(
uplo: *const c_char,
n: *const lapack_int,
ap: *mut c_float,
ipiv: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dsptrf_(
uplo: *const c_char,
n: *const lapack_int,
ap: *mut c_double,
ipiv: *mut lapack_int,
info: *mut lapack_int,
);
pub fn csptrf_(
uplo: *const c_char,
n: *const lapack_int,
ap: *mut lapack_complex_float,
ipiv: *mut lapack_int,
info: *mut lapack_int,
);
pub fn zsptrf_(
uplo: *const c_char,
n: *const lapack_int,
ap: *mut lapack_complex_double,
ipiv: *mut lapack_int,
info: *mut lapack_int,
);
pub fn chptrf_(
uplo: *const c_char,
n: *const lapack_int,
ap: *mut lapack_complex_float,
ipiv: *mut lapack_int,
info: *mut lapack_int,
);
pub fn zhptrf_(
uplo: *const c_char,
n: *const lapack_int,
ap: *mut lapack_complex_double,
ipiv: *mut lapack_int,
info: *mut lapack_int,
);
pub fn sgetrs_(
trans: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const c_float,
lda: *const lapack_int,
ipiv: *const lapack_int,
b: *mut c_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn dgetrs_(
trans: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const c_double,
lda: *const lapack_int,
ipiv: *const lapack_int,
b: *mut c_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn cgetrs_(
trans: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
ipiv: *const lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn zgetrs_(
trans: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
ipiv: *const lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn sgbtrs_(
trans: *const c_char,
n: *const lapack_int,
kl: *const lapack_int,
ku: *const lapack_int,
nrhs: *const lapack_int,
ab: *const c_float,
ldab: *const lapack_int,
ipiv: *const lapack_int,
b: *mut c_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn dgbtrs_(
trans: *const c_char,
n: *const lapack_int,
kl: *const lapack_int,
ku: *const lapack_int,
nrhs: *const lapack_int,
ab: *const c_double,
ldab: *const lapack_int,
ipiv: *const lapack_int,
b: *mut c_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn cgbtrs_(
trans: *const c_char,
n: *const lapack_int,
kl: *const lapack_int,
ku: *const lapack_int,
nrhs: *const lapack_int,
ab: *const lapack_complex_float,
ldab: *const lapack_int,
ipiv: *const lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn zgbtrs_(
trans: *const c_char,
n: *const lapack_int,
kl: *const lapack_int,
ku: *const lapack_int,
nrhs: *const lapack_int,
ab: *const lapack_complex_double,
ldab: *const lapack_int,
ipiv: *const lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn sgttrs_(
trans: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
dl: *const c_float,
d: *const c_float,
du: *const c_float,
du2: *const c_float,
ipiv: *const lapack_int,
b: *mut c_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn dgttrs_(
trans: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
dl: *const c_double,
d: *const c_double,
du: *const c_double,
du2: *const c_double,
ipiv: *const lapack_int,
b: *mut c_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn cgttrs_(
trans: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
dl: *const lapack_complex_float,
d: *const lapack_complex_float,
du: *const lapack_complex_float,
du2: *const lapack_complex_float,
ipiv: *const lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn zgttrs_(
trans: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
dl: *const lapack_complex_double,
d: *const lapack_complex_double,
du: *const lapack_complex_double,
du2: *const lapack_complex_double,
ipiv: *const lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn spotrs_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const c_float,
lda: *const lapack_int,
b: *mut c_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn dpotrs_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const c_double,
lda: *const lapack_int,
b: *mut c_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn cpotrs_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn zpotrs_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn dpftrs_(
transr: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const c_double,
b: *mut c_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn spftrs_(
transr: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const c_float,
b: *mut c_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn zpftrs_(
transr: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const lapack_complex_double,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn cpftrs_(
transr: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const lapack_complex_float,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn spptrs_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
ap: *const c_float,
b: *mut c_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn dpptrs_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
ap: *const c_double,
b: *mut c_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn cpptrs_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
ap: *const lapack_complex_float,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn zpptrs_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
ap: *const lapack_complex_double,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn spbtrs_(
uplo: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
nrhs: *const lapack_int,
ab: *const c_float,
ldab: *const lapack_int,
b: *mut c_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn dpbtrs_(
uplo: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
nrhs: *const lapack_int,
ab: *const c_double,
ldab: *const lapack_int,
b: *mut c_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn cpbtrs_(
uplo: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
nrhs: *const lapack_int,
ab: *const lapack_complex_float,
ldab: *const lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn zpbtrs_(
uplo: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
nrhs: *const lapack_int,
ab: *const lapack_complex_double,
ldab: *const lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn spttrs_(
n: *const lapack_int,
nrhs: *const lapack_int,
d: *const c_float,
e: *const c_float,
b: *mut c_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn dpttrs_(
n: *const lapack_int,
nrhs: *const lapack_int,
d: *const c_double,
e: *const c_double,
b: *mut c_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn cpttrs_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
d: *const c_float,
e: *const lapack_complex_float,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn zpttrs_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
d: *const c_double,
e: *const lapack_complex_double,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn ssytrs_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const c_float,
lda: *const lapack_int,
ipiv: *const lapack_int,
b: *mut c_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn dsytrs_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const c_double,
lda: *const lapack_int,
ipiv: *const lapack_int,
b: *mut c_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn csytrs_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
ipiv: *const lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn zsytrs_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
ipiv: *const lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn chetrs_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
ipiv: *const lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn zhetrs_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
ipiv: *const lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn ssptrs_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
ap: *const c_float,
ipiv: *const lapack_int,
b: *mut c_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn dsptrs_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
ap: *const c_double,
ipiv: *const lapack_int,
b: *mut c_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn csptrs_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
ap: *const lapack_complex_float,
ipiv: *const lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn zsptrs_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
ap: *const lapack_complex_double,
ipiv: *const lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn chptrs_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
ap: *const lapack_complex_float,
ipiv: *const lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn zhptrs_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
ap: *const lapack_complex_double,
ipiv: *const lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn strtrs_(
uplo: *const c_char,
trans: *const c_char,
diag: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const c_float,
lda: *const lapack_int,
b: *mut c_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn dtrtrs_(
uplo: *const c_char,
trans: *const c_char,
diag: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const c_double,
lda: *const lapack_int,
b: *mut c_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn ctrtrs_(
uplo: *const c_char,
trans: *const c_char,
diag: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn ztrtrs_(
uplo: *const c_char,
trans: *const c_char,
diag: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn stptrs_(
uplo: *const c_char,
trans: *const c_char,
diag: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
ap: *const c_float,
b: *mut c_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn dtptrs_(
uplo: *const c_char,
trans: *const c_char,
diag: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
ap: *const c_double,
b: *mut c_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn ctptrs_(
uplo: *const c_char,
trans: *const c_char,
diag: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
ap: *const lapack_complex_float,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn ztptrs_(
uplo: *const c_char,
trans: *const c_char,
diag: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
ap: *const lapack_complex_double,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn stbtrs_(
uplo: *const c_char,
trans: *const c_char,
diag: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
nrhs: *const lapack_int,
ab: *const c_float,
ldab: *const lapack_int,
b: *mut c_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn dtbtrs_(
uplo: *const c_char,
trans: *const c_char,
diag: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
nrhs: *const lapack_int,
ab: *const c_double,
ldab: *const lapack_int,
b: *mut c_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn ctbtrs_(
uplo: *const c_char,
trans: *const c_char,
diag: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
nrhs: *const lapack_int,
ab: *const lapack_complex_float,
ldab: *const lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn ztbtrs_(
uplo: *const c_char,
trans: *const c_char,
diag: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
nrhs: *const lapack_int,
ab: *const lapack_complex_double,
ldab: *const lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn sgecon_(
norm: *const c_char,
n: *const lapack_int,
a: *const c_float,
lda: *const lapack_int,
anorm: *const c_float,
rcond: *mut c_float,
work: *mut c_float,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dgecon_(
norm: *const c_char,
n: *const lapack_int,
a: *const c_double,
lda: *const lapack_int,
anorm: *const c_double,
rcond: *mut c_double,
work: *mut c_double,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn cgecon_(
norm: *const c_char,
n: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
anorm: *const c_float,
rcond: *mut c_float,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn zgecon_(
norm: *const c_char,
n: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
anorm: *const c_double,
rcond: *mut c_double,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn sgbcon_(
norm: *const c_char,
n: *const lapack_int,
kl: *const lapack_int,
ku: *const lapack_int,
ab: *const c_float,
ldab: *const lapack_int,
ipiv: *const lapack_int,
anorm: *const c_float,
rcond: *mut c_float,
work: *mut c_float,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dgbcon_(
norm: *const c_char,
n: *const lapack_int,
kl: *const lapack_int,
ku: *const lapack_int,
ab: *const c_double,
ldab: *const lapack_int,
ipiv: *const lapack_int,
anorm: *const c_double,
rcond: *mut c_double,
work: *mut c_double,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn cgbcon_(
norm: *const c_char,
n: *const lapack_int,
kl: *const lapack_int,
ku: *const lapack_int,
ab: *const lapack_complex_float,
ldab: *const lapack_int,
ipiv: *const lapack_int,
anorm: *const c_float,
rcond: *mut c_float,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn zgbcon_(
norm: *const c_char,
n: *const lapack_int,
kl: *const lapack_int,
ku: *const lapack_int,
ab: *const lapack_complex_double,
ldab: *const lapack_int,
ipiv: *const lapack_int,
anorm: *const c_double,
rcond: *mut c_double,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn sgtcon_(
norm: *const c_char,
n: *const lapack_int,
dl: *const c_float,
d: *const c_float,
du: *const c_float,
du2: *const c_float,
ipiv: *const lapack_int,
anorm: *const c_float,
rcond: *mut c_float,
work: *mut c_float,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dgtcon_(
norm: *const c_char,
n: *const lapack_int,
dl: *const c_double,
d: *const c_double,
du: *const c_double,
du2: *const c_double,
ipiv: *const lapack_int,
anorm: *const c_double,
rcond: *mut c_double,
work: *mut c_double,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn cgtcon_(
norm: *const c_char,
n: *const lapack_int,
dl: *const lapack_complex_float,
d: *const lapack_complex_float,
du: *const lapack_complex_float,
du2: *const lapack_complex_float,
ipiv: *const lapack_int,
anorm: *const c_float,
rcond: *mut c_float,
work: *mut lapack_complex_float,
info: *mut lapack_int,
);
pub fn zgtcon_(
norm: *const c_char,
n: *const lapack_int,
dl: *const lapack_complex_double,
d: *const lapack_complex_double,
du: *const lapack_complex_double,
du2: *const lapack_complex_double,
ipiv: *const lapack_int,
anorm: *const c_double,
rcond: *mut c_double,
work: *mut lapack_complex_double,
info: *mut lapack_int,
);
pub fn spocon_(
uplo: *const c_char,
n: *const lapack_int,
a: *const c_float,
lda: *const lapack_int,
anorm: *const c_float,
rcond: *mut c_float,
work: *mut c_float,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dpocon_(
uplo: *const c_char,
n: *const lapack_int,
a: *const c_double,
lda: *const lapack_int,
anorm: *const c_double,
rcond: *mut c_double,
work: *mut c_double,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn cpocon_(
uplo: *const c_char,
n: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
anorm: *const c_float,
rcond: *mut c_float,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn zpocon_(
uplo: *const c_char,
n: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
anorm: *const c_double,
rcond: *mut c_double,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn sppcon_(
uplo: *const c_char,
n: *const lapack_int,
ap: *const c_float,
anorm: *const c_float,
rcond: *mut c_float,
work: *mut c_float,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dppcon_(
uplo: *const c_char,
n: *const lapack_int,
ap: *const c_double,
anorm: *const c_double,
rcond: *mut c_double,
work: *mut c_double,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn cppcon_(
uplo: *const c_char,
n: *const lapack_int,
ap: *const lapack_complex_float,
anorm: *const c_float,
rcond: *mut c_float,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn zppcon_(
uplo: *const c_char,
n: *const lapack_int,
ap: *const lapack_complex_double,
anorm: *const c_double,
rcond: *mut c_double,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn spbcon_(
uplo: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
ab: *const c_float,
ldab: *const lapack_int,
anorm: *const c_float,
rcond: *mut c_float,
work: *mut c_float,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dpbcon_(
uplo: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
ab: *const c_double,
ldab: *const lapack_int,
anorm: *const c_double,
rcond: *mut c_double,
work: *mut c_double,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn cpbcon_(
uplo: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
ab: *const lapack_complex_float,
ldab: *const lapack_int,
anorm: *const c_float,
rcond: *mut c_float,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn zpbcon_(
uplo: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
ab: *const lapack_complex_double,
ldab: *const lapack_int,
anorm: *const c_double,
rcond: *mut c_double,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn sptcon_(
n: *const lapack_int,
d: *const c_float,
e: *const c_float,
anorm: *const c_float,
rcond: *mut c_float,
work: *mut c_float,
info: *mut lapack_int,
);
pub fn dptcon_(
n: *const lapack_int,
d: *const c_double,
e: *const c_double,
anorm: *const c_double,
rcond: *mut c_double,
work: *mut c_double,
info: *mut lapack_int,
);
pub fn cptcon_(
n: *const lapack_int,
d: *const c_float,
e: *const lapack_complex_float,
anorm: *const c_float,
rcond: *mut c_float,
work: *mut c_float,
info: *mut lapack_int,
);
pub fn zptcon_(
n: *const lapack_int,
d: *const c_double,
e: *const lapack_complex_double,
anorm: *const c_double,
rcond: *mut c_double,
work: *mut c_double,
info: *mut lapack_int,
);
pub fn ssycon_(
uplo: *const c_char,
n: *const lapack_int,
a: *const c_float,
lda: *const lapack_int,
ipiv: *const lapack_int,
anorm: *const c_float,
rcond: *mut c_float,
work: *mut c_float,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dsycon_(
uplo: *const c_char,
n: *const lapack_int,
a: *const c_double,
lda: *const lapack_int,
ipiv: *const lapack_int,
anorm: *const c_double,
rcond: *mut c_double,
work: *mut c_double,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn csycon_(
uplo: *const c_char,
n: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
ipiv: *const lapack_int,
anorm: *const c_float,
rcond: *mut c_float,
work: *mut lapack_complex_float,
info: *mut lapack_int,
);
pub fn zsycon_(
uplo: *const c_char,
n: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
ipiv: *const lapack_int,
anorm: *const c_double,
rcond: *mut c_double,
work: *mut lapack_complex_double,
info: *mut lapack_int,
);
pub fn checon_(
uplo: *const c_char,
n: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
ipiv: *const lapack_int,
anorm: *const c_float,
rcond: *mut c_float,
work: *mut lapack_complex_float,
info: *mut lapack_int,
);
pub fn zhecon_(
uplo: *const c_char,
n: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
ipiv: *const lapack_int,
anorm: *const c_double,
rcond: *mut c_double,
work: *mut lapack_complex_double,
info: *mut lapack_int,
);
pub fn sspcon_(
uplo: *const c_char,
n: *const lapack_int,
ap: *const c_float,
ipiv: *const lapack_int,
anorm: *const c_float,
rcond: *mut c_float,
work: *mut c_float,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dspcon_(
uplo: *const c_char,
n: *const lapack_int,
ap: *const c_double,
ipiv: *const lapack_int,
anorm: *const c_double,
rcond: *mut c_double,
work: *mut c_double,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn cspcon_(
uplo: *const c_char,
n: *const lapack_int,
ap: *const lapack_complex_float,
ipiv: *const lapack_int,
anorm: *const c_float,
rcond: *mut c_float,
work: *mut lapack_complex_float,
info: *mut lapack_int,
);
pub fn zspcon_(
uplo: *const c_char,
n: *const lapack_int,
ap: *const lapack_complex_double,
ipiv: *const lapack_int,
anorm: *const c_double,
rcond: *mut c_double,
work: *mut lapack_complex_double,
info: *mut lapack_int,
);
pub fn chpcon_(
uplo: *const c_char,
n: *const lapack_int,
ap: *const lapack_complex_float,
ipiv: *const lapack_int,
anorm: *const c_float,
rcond: *mut c_float,
work: *mut lapack_complex_float,
info: *mut lapack_int,
);
pub fn zhpcon_(
uplo: *const c_char,
n: *const lapack_int,
ap: *const lapack_complex_double,
ipiv: *const lapack_int,
anorm: *const c_double,
rcond: *mut c_double,
work: *mut lapack_complex_double,
info: *mut lapack_int,
);
pub fn strcon_(
norm: *const c_char,
uplo: *const c_char,
diag: *const c_char,
n: *const lapack_int,
a: *const c_float,
lda: *const lapack_int,
rcond: *mut c_float,
work: *mut c_float,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dtrcon_(
norm: *const c_char,
uplo: *const c_char,
diag: *const c_char,
n: *const lapack_int,
a: *const c_double,
lda: *const lapack_int,
rcond: *mut c_double,
work: *mut c_double,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn ctrcon_(
norm: *const c_char,
uplo: *const c_char,
diag: *const c_char,
n: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
rcond: *mut c_float,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn ztrcon_(
norm: *const c_char,
uplo: *const c_char,
diag: *const c_char,
n: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
rcond: *mut c_double,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn stpcon_(
norm: *const c_char,
uplo: *const c_char,
diag: *const c_char,
n: *const lapack_int,
ap: *const c_float,
rcond: *mut c_float,
work: *mut c_float,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dtpcon_(
norm: *const c_char,
uplo: *const c_char,
diag: *const c_char,
n: *const lapack_int,
ap: *const c_double,
rcond: *mut c_double,
work: *mut c_double,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn ctpcon_(
norm: *const c_char,
uplo: *const c_char,
diag: *const c_char,
n: *const lapack_int,
ap: *const lapack_complex_float,
rcond: *mut c_float,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn ztpcon_(
norm: *const c_char,
uplo: *const c_char,
diag: *const c_char,
n: *const lapack_int,
ap: *const lapack_complex_double,
rcond: *mut c_double,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn stbcon_(
norm: *const c_char,
uplo: *const c_char,
diag: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
ab: *const c_float,
ldab: *const lapack_int,
rcond: *mut c_float,
work: *mut c_float,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dtbcon_(
norm: *const c_char,
uplo: *const c_char,
diag: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
ab: *const c_double,
ldab: *const lapack_int,
rcond: *mut c_double,
work: *mut c_double,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn ctbcon_(
norm: *const c_char,
uplo: *const c_char,
diag: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
ab: *const lapack_complex_float,
ldab: *const lapack_int,
rcond: *mut c_float,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn ztbcon_(
norm: *const c_char,
uplo: *const c_char,
diag: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
ab: *const lapack_complex_double,
ldab: *const lapack_int,
rcond: *mut c_double,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn sgerfs_(
trans: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const c_float,
lda: *const lapack_int,
af: *const c_float,
ldaf: *const lapack_int,
ipiv: *const lapack_int,
b: *const c_float,
ldb: *const lapack_int,
x: *mut c_float,
ldx: *const lapack_int,
ferr: *mut c_float,
berr: *mut c_float,
work: *mut c_float,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dgerfs_(
trans: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const c_double,
lda: *const lapack_int,
af: *const c_double,
ldaf: *const lapack_int,
ipiv: *const lapack_int,
b: *const c_double,
ldb: *const lapack_int,
x: *mut c_double,
ldx: *const lapack_int,
ferr: *mut c_double,
berr: *mut c_double,
work: *mut c_double,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn cgerfs_(
trans: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
af: *const lapack_complex_float,
ldaf: *const lapack_int,
ipiv: *const lapack_int,
b: *const lapack_complex_float,
ldb: *const lapack_int,
x: *mut lapack_complex_float,
ldx: *const lapack_int,
ferr: *mut c_float,
berr: *mut c_float,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn zgerfs_(
trans: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
af: *const lapack_complex_double,
ldaf: *const lapack_int,
ipiv: *const lapack_int,
b: *const lapack_complex_double,
ldb: *const lapack_int,
x: *mut lapack_complex_double,
ldx: *const lapack_int,
ferr: *mut c_double,
berr: *mut c_double,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn dgerfsx_(
trans: *const c_char,
equed: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const c_double,
lda: *const lapack_int,
af: *const c_double,
ldaf: *const lapack_int,
ipiv: *const lapack_int,
r: *const c_double,
c: *const c_double,
b: *const c_double,
ldb: *const lapack_int,
x: *mut c_double,
ldx: *const lapack_int,
rcond: *mut c_double,
berr: *mut c_double,
n_err_bnds: *const lapack_int,
err_bnds_norm: *mut c_double,
err_bnds_comp: *mut c_double,
nparams: *const lapack_int,
params: *mut c_double,
work: *mut c_double,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn sgerfsx_(
trans: *const c_char,
equed: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const c_float,
lda: *const lapack_int,
af: *const c_float,
ldaf: *const lapack_int,
ipiv: *const lapack_int,
r: *const c_float,
c: *const c_float,
b: *const c_float,
ldb: *const lapack_int,
x: *mut c_float,
ldx: *const lapack_int,
rcond: *mut c_float,
berr: *mut c_float,
n_err_bnds: *const lapack_int,
err_bnds_norm: *mut c_float,
err_bnds_comp: *mut c_float,
nparams: *const lapack_int,
params: *mut c_float,
work: *mut c_float,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn zgerfsx_(
trans: *const c_char,
equed: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
af: *const lapack_complex_double,
ldaf: *const lapack_int,
ipiv: *const lapack_int,
r: *const c_double,
c: *const c_double,
b: *const lapack_complex_double,
ldb: *const lapack_int,
x: *mut lapack_complex_double,
ldx: *const lapack_int,
rcond: *mut c_double,
berr: *mut c_double,
n_err_bnds: *const lapack_int,
err_bnds_norm: *mut c_double,
err_bnds_comp: *mut c_double,
nparams: *const lapack_int,
params: *mut c_double,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn cgerfsx_(
trans: *const c_char,
equed: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
af: *const lapack_complex_float,
ldaf: *const lapack_int,
ipiv: *const lapack_int,
r: *const c_float,
c: *const c_float,
b: *const lapack_complex_float,
ldb: *const lapack_int,
x: *mut lapack_complex_float,
ldx: *const lapack_int,
rcond: *mut c_float,
berr: *mut c_float,
n_err_bnds: *const lapack_int,
err_bnds_norm: *mut c_float,
err_bnds_comp: *mut c_float,
nparams: *const lapack_int,
params: *mut c_float,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn sgbrfs_(
trans: *const c_char,
n: *const lapack_int,
kl: *const lapack_int,
ku: *const lapack_int,
nrhs: *const lapack_int,
ab: *const c_float,
ldab: *const lapack_int,
afb: *const c_float,
ldafb: *const lapack_int,
ipiv: *const lapack_int,
b: *const c_float,
ldb: *const lapack_int,
x: *mut c_float,
ldx: *const lapack_int,
ferr: *mut c_float,
berr: *mut c_float,
work: *mut c_float,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dgbrfs_(
trans: *const c_char,
n: *const lapack_int,
kl: *const lapack_int,
ku: *const lapack_int,
nrhs: *const lapack_int,
ab: *const c_double,
ldab: *const lapack_int,
afb: *const c_double,
ldafb: *const lapack_int,
ipiv: *const lapack_int,
b: *const c_double,
ldb: *const lapack_int,
x: *mut c_double,
ldx: *const lapack_int,
ferr: *mut c_double,
berr: *mut c_double,
work: *mut c_double,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn cgbrfs_(
trans: *const c_char,
n: *const lapack_int,
kl: *const lapack_int,
ku: *const lapack_int,
nrhs: *const lapack_int,
ab: *const lapack_complex_float,
ldab: *const lapack_int,
afb: *const lapack_complex_float,
ldafb: *const lapack_int,
ipiv: *const lapack_int,
b: *const lapack_complex_float,
ldb: *const lapack_int,
x: *mut lapack_complex_float,
ldx: *const lapack_int,
ferr: *mut c_float,
berr: *mut c_float,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn zgbrfs_(
trans: *const c_char,
n: *const lapack_int,
kl: *const lapack_int,
ku: *const lapack_int,
nrhs: *const lapack_int,
ab: *const lapack_complex_double,
ldab: *const lapack_int,
afb: *const lapack_complex_double,
ldafb: *const lapack_int,
ipiv: *const lapack_int,
b: *const lapack_complex_double,
ldb: *const lapack_int,
x: *mut lapack_complex_double,
ldx: *const lapack_int,
ferr: *mut c_double,
berr: *mut c_double,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn dgbrfsx_(
trans: *const c_char,
equed: *const c_char,
n: *const lapack_int,
kl: *const lapack_int,
ku: *const lapack_int,
nrhs: *const lapack_int,
ab: *const c_double,
ldab: *const lapack_int,
afb: *const c_double,
ldafb: *const lapack_int,
ipiv: *const lapack_int,
r: *const c_double,
c: *const c_double,
b: *const c_double,
ldb: *const lapack_int,
x: *mut c_double,
ldx: *const lapack_int,
rcond: *mut c_double,
berr: *mut c_double,
n_err_bnds: *const lapack_int,
err_bnds_norm: *mut c_double,
err_bnds_comp: *mut c_double,
nparams: *const lapack_int,
params: *mut c_double,
work: *mut c_double,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn sgbrfsx_(
trans: *const c_char,
equed: *const c_char,
n: *const lapack_int,
kl: *const lapack_int,
ku: *const lapack_int,
nrhs: *const lapack_int,
ab: *const c_float,
ldab: *const lapack_int,
afb: *const c_float,
ldafb: *const lapack_int,
ipiv: *const lapack_int,
r: *const c_float,
c: *const c_float,
b: *const c_float,
ldb: *const lapack_int,
x: *mut c_float,
ldx: *const lapack_int,
rcond: *mut c_float,
berr: *mut c_float,
n_err_bnds: *const lapack_int,
err_bnds_norm: *mut c_float,
err_bnds_comp: *mut c_float,
nparams: *const lapack_int,
params: *mut c_float,
work: *mut c_float,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn zgbrfsx_(
trans: *const c_char,
equed: *const c_char,
n: *const lapack_int,
kl: *const lapack_int,
ku: *const lapack_int,
nrhs: *const lapack_int,
ab: *const lapack_complex_double,
ldab: *const lapack_int,
afb: *const lapack_complex_double,
ldafb: *const lapack_int,
ipiv: *const lapack_int,
r: *const c_double,
c: *const c_double,
b: *const lapack_complex_double,
ldb: *const lapack_int,
x: *mut lapack_complex_double,
ldx: *const lapack_int,
rcond: *mut c_double,
berr: *mut c_double,
n_err_bnds: *const lapack_int,
err_bnds_norm: *mut c_double,
err_bnds_comp: *mut c_double,
nparams: *const lapack_int,
params: *mut c_double,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn cgbrfsx_(
trans: *const c_char,
equed: *const c_char,
n: *const lapack_int,
kl: *const lapack_int,
ku: *const lapack_int,
nrhs: *const lapack_int,
ab: *const lapack_complex_float,
ldab: *const lapack_int,
afb: *const lapack_complex_float,
ldafb: *const lapack_int,
ipiv: *const lapack_int,
r: *const c_float,
c: *const c_float,
b: *const lapack_complex_float,
ldb: *const lapack_int,
x: *mut lapack_complex_float,
ldx: *const lapack_int,
rcond: *mut c_float,
berr: *mut c_float,
n_err_bnds: *const lapack_int,
err_bnds_norm: *mut c_float,
err_bnds_comp: *mut c_float,
nparams: *const lapack_int,
params: *mut c_float,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn sgtrfs_(
trans: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
dl: *const c_float,
d: *const c_float,
du: *const c_float,
dlf: *const c_float,
df: *const c_float,
duf: *const c_float,
du2: *const c_float,
ipiv: *const lapack_int,
b: *const c_float,
ldb: *const lapack_int,
x: *mut c_float,
ldx: *const lapack_int,
ferr: *mut c_float,
berr: *mut c_float,
work: *mut c_float,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dgtrfs_(
trans: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
dl: *const c_double,
d: *const c_double,
du: *const c_double,
dlf: *const c_double,
df: *const c_double,
duf: *const c_double,
du2: *const c_double,
ipiv: *const lapack_int,
b: *const c_double,
ldb: *const lapack_int,
x: *mut c_double,
ldx: *const lapack_int,
ferr: *mut c_double,
berr: *mut c_double,
work: *mut c_double,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn cgtrfs_(
trans: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
dl: *const lapack_complex_float,
d: *const lapack_complex_float,
du: *const lapack_complex_float,
dlf: *const lapack_complex_float,
df: *const lapack_complex_float,
duf: *const lapack_complex_float,
du2: *const lapack_complex_float,
ipiv: *const lapack_int,
b: *const lapack_complex_float,
ldb: *const lapack_int,
x: *mut lapack_complex_float,
ldx: *const lapack_int,
ferr: *mut c_float,
berr: *mut c_float,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn zgtrfs_(
trans: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
dl: *const lapack_complex_double,
d: *const lapack_complex_double,
du: *const lapack_complex_double,
dlf: *const lapack_complex_double,
df: *const lapack_complex_double,
duf: *const lapack_complex_double,
du2: *const lapack_complex_double,
ipiv: *const lapack_int,
b: *const lapack_complex_double,
ldb: *const lapack_int,
x: *mut lapack_complex_double,
ldx: *const lapack_int,
ferr: *mut c_double,
berr: *mut c_double,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn sporfs_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const c_float,
lda: *const lapack_int,
af: *const c_float,
ldaf: *const lapack_int,
b: *const c_float,
ldb: *const lapack_int,
x: *mut c_float,
ldx: *const lapack_int,
ferr: *mut c_float,
berr: *mut c_float,
work: *mut c_float,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dporfs_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const c_double,
lda: *const lapack_int,
af: *const c_double,
ldaf: *const lapack_int,
b: *const c_double,
ldb: *const lapack_int,
x: *mut c_double,
ldx: *const lapack_int,
ferr: *mut c_double,
berr: *mut c_double,
work: *mut c_double,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn cporfs_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
af: *const lapack_complex_float,
ldaf: *const lapack_int,
b: *const lapack_complex_float,
ldb: *const lapack_int,
x: *mut lapack_complex_float,
ldx: *const lapack_int,
ferr: *mut c_float,
berr: *mut c_float,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn zporfs_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
af: *const lapack_complex_double,
ldaf: *const lapack_int,
b: *const lapack_complex_double,
ldb: *const lapack_int,
x: *mut lapack_complex_double,
ldx: *const lapack_int,
ferr: *mut c_double,
berr: *mut c_double,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn dporfsx_(
uplo: *const c_char,
equed: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const c_double,
lda: *const lapack_int,
af: *const c_double,
ldaf: *const lapack_int,
s: *const c_double,
b: *const c_double,
ldb: *const lapack_int,
x: *mut c_double,
ldx: *const lapack_int,
rcond: *mut c_double,
berr: *mut c_double,
n_err_bnds: *const lapack_int,
err_bnds_norm: *mut c_double,
err_bnds_comp: *mut c_double,
nparams: *const lapack_int,
params: *mut c_double,
work: *mut c_double,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn sporfsx_(
uplo: *const c_char,
equed: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const c_float,
lda: *const lapack_int,
af: *const c_float,
ldaf: *const lapack_int,
s: *const c_float,
b: *const c_float,
ldb: *const lapack_int,
x: *mut c_float,
ldx: *const lapack_int,
rcond: *mut c_float,
berr: *mut c_float,
n_err_bnds: *const lapack_int,
err_bnds_norm: *mut c_float,
err_bnds_comp: *mut c_float,
nparams: *const lapack_int,
params: *mut c_float,
work: *mut c_float,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn zporfsx_(
uplo: *const c_char,
equed: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
af: *const lapack_complex_double,
ldaf: *const lapack_int,
s: *const c_double,
b: *const lapack_complex_double,
ldb: *const lapack_int,
x: *mut lapack_complex_double,
ldx: *const lapack_int,
rcond: *mut c_double,
berr: *mut c_double,
n_err_bnds: *const lapack_int,
err_bnds_norm: *mut c_double,
err_bnds_comp: *mut c_double,
nparams: *const lapack_int,
params: *mut c_double,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn cporfsx_(
uplo: *const c_char,
equed: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
af: *const lapack_complex_float,
ldaf: *const lapack_int,
s: *const c_float,
b: *const lapack_complex_float,
ldb: *const lapack_int,
x: *mut lapack_complex_float,
ldx: *const lapack_int,
rcond: *mut c_float,
berr: *mut c_float,
n_err_bnds: *const lapack_int,
err_bnds_norm: *mut c_float,
err_bnds_comp: *mut c_float,
nparams: *const lapack_int,
params: *mut c_float,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn spprfs_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
ap: *const c_float,
afp: *const c_float,
b: *const c_float,
ldb: *const lapack_int,
x: *mut c_float,
ldx: *const lapack_int,
ferr: *mut c_float,
berr: *mut c_float,
work: *mut c_float,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dpprfs_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
ap: *const c_double,
afp: *const c_double,
b: *const c_double,
ldb: *const lapack_int,
x: *mut c_double,
ldx: *const lapack_int,
ferr: *mut c_double,
berr: *mut c_double,
work: *mut c_double,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn cpprfs_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
ap: *const lapack_complex_float,
afp: *const lapack_complex_float,
b: *const lapack_complex_float,
ldb: *const lapack_int,
x: *mut lapack_complex_float,
ldx: *const lapack_int,
ferr: *mut c_float,
berr: *mut c_float,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn zpprfs_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
ap: *const lapack_complex_double,
afp: *const lapack_complex_double,
b: *const lapack_complex_double,
ldb: *const lapack_int,
x: *mut lapack_complex_double,
ldx: *const lapack_int,
ferr: *mut c_double,
berr: *mut c_double,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn spbrfs_(
uplo: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
nrhs: *const lapack_int,
ab: *const c_float,
ldab: *const lapack_int,
afb: *const c_float,
ldafb: *const lapack_int,
b: *const c_float,
ldb: *const lapack_int,
x: *mut c_float,
ldx: *const lapack_int,
ferr: *mut c_float,
berr: *mut c_float,
work: *mut c_float,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dpbrfs_(
uplo: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
nrhs: *const lapack_int,
ab: *const c_double,
ldab: *const lapack_int,
afb: *const c_double,
ldafb: *const lapack_int,
b: *const c_double,
ldb: *const lapack_int,
x: *mut c_double,
ldx: *const lapack_int,
ferr: *mut c_double,
berr: *mut c_double,
work: *mut c_double,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn cpbrfs_(
uplo: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
nrhs: *const lapack_int,
ab: *const lapack_complex_float,
ldab: *const lapack_int,
afb: *const lapack_complex_float,
ldafb: *const lapack_int,
b: *const lapack_complex_float,
ldb: *const lapack_int,
x: *mut lapack_complex_float,
ldx: *const lapack_int,
ferr: *mut c_float,
berr: *mut c_float,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn zpbrfs_(
uplo: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
nrhs: *const lapack_int,
ab: *const lapack_complex_double,
ldab: *const lapack_int,
afb: *const lapack_complex_double,
ldafb: *const lapack_int,
b: *const lapack_complex_double,
ldb: *const lapack_int,
x: *mut lapack_complex_double,
ldx: *const lapack_int,
ferr: *mut c_double,
berr: *mut c_double,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn sptrfs_(
n: *const lapack_int,
nrhs: *const lapack_int,
d: *const c_float,
e: *const c_float,
df: *const c_float,
ef: *const c_float,
b: *const c_float,
ldb: *const lapack_int,
x: *mut c_float,
ldx: *const lapack_int,
ferr: *mut c_float,
berr: *mut c_float,
work: *mut c_float,
info: *mut lapack_int,
);
pub fn dptrfs_(
n: *const lapack_int,
nrhs: *const lapack_int,
d: *const c_double,
e: *const c_double,
df: *const c_double,
ef: *const c_double,
b: *const c_double,
ldb: *const lapack_int,
x: *mut c_double,
ldx: *const lapack_int,
ferr: *mut c_double,
berr: *mut c_double,
work: *mut c_double,
info: *mut lapack_int,
);
pub fn cptrfs_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
d: *const c_float,
e: *const lapack_complex_float,
df: *const c_float,
ef: *const lapack_complex_float,
b: *const lapack_complex_float,
ldb: *const lapack_int,
x: *mut lapack_complex_float,
ldx: *const lapack_int,
ferr: *mut c_float,
berr: *mut c_float,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn zptrfs_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
d: *const c_double,
e: *const lapack_complex_double,
df: *const c_double,
ef: *const lapack_complex_double,
b: *const lapack_complex_double,
ldb: *const lapack_int,
x: *mut lapack_complex_double,
ldx: *const lapack_int,
ferr: *mut c_double,
berr: *mut c_double,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn ssyrfs_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const c_float,
lda: *const lapack_int,
af: *const c_float,
ldaf: *const lapack_int,
ipiv: *const lapack_int,
b: *const c_float,
ldb: *const lapack_int,
x: *mut c_float,
ldx: *const lapack_int,
ferr: *mut c_float,
berr: *mut c_float,
work: *mut c_float,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dsyrfs_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const c_double,
lda: *const lapack_int,
af: *const c_double,
ldaf: *const lapack_int,
ipiv: *const lapack_int,
b: *const c_double,
ldb: *const lapack_int,
x: *mut c_double,
ldx: *const lapack_int,
ferr: *mut c_double,
berr: *mut c_double,
work: *mut c_double,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn csyrfs_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
af: *const lapack_complex_float,
ldaf: *const lapack_int,
ipiv: *const lapack_int,
b: *const lapack_complex_float,
ldb: *const lapack_int,
x: *mut lapack_complex_float,
ldx: *const lapack_int,
ferr: *mut c_float,
berr: *mut c_float,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn zsyrfs_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
af: *const lapack_complex_double,
ldaf: *const lapack_int,
ipiv: *const lapack_int,
b: *const lapack_complex_double,
ldb: *const lapack_int,
x: *mut lapack_complex_double,
ldx: *const lapack_int,
ferr: *mut c_double,
berr: *mut c_double,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn dsyrfsx_(
uplo: *const c_char,
equed: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const c_double,
lda: *const lapack_int,
af: *const c_double,
ldaf: *const lapack_int,
ipiv: *const lapack_int,
s: *const c_double,
b: *const c_double,
ldb: *const lapack_int,
x: *mut c_double,
ldx: *const lapack_int,
rcond: *mut c_double,
berr: *mut c_double,
n_err_bnds: *const lapack_int,
err_bnds_norm: *mut c_double,
err_bnds_comp: *mut c_double,
nparams: *const lapack_int,
params: *mut c_double,
work: *mut c_double,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn ssyrfsx_(
uplo: *const c_char,
equed: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const c_float,
lda: *const lapack_int,
af: *const c_float,
ldaf: *const lapack_int,
ipiv: *const lapack_int,
s: *const c_float,
b: *const c_float,
ldb: *const lapack_int,
x: *mut c_float,
ldx: *const lapack_int,
rcond: *mut c_float,
berr: *mut c_float,
n_err_bnds: *const lapack_int,
err_bnds_norm: *mut c_float,
err_bnds_comp: *mut c_float,
nparams: *const lapack_int,
params: *mut c_float,
work: *mut c_float,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn zsyrfsx_(
uplo: *const c_char,
equed: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
af: *const lapack_complex_double,
ldaf: *const lapack_int,
ipiv: *const lapack_int,
s: *const c_double,
b: *const lapack_complex_double,
ldb: *const lapack_int,
x: *mut lapack_complex_double,
ldx: *const lapack_int,
rcond: *mut c_double,
berr: *mut c_double,
n_err_bnds: *const lapack_int,
err_bnds_norm: *mut c_double,
err_bnds_comp: *mut c_double,
nparams: *const lapack_int,
params: *mut c_double,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn csyrfsx_(
uplo: *const c_char,
equed: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
af: *const lapack_complex_float,
ldaf: *const lapack_int,
ipiv: *const lapack_int,
s: *const c_float,
b: *const lapack_complex_float,
ldb: *const lapack_int,
x: *mut lapack_complex_float,
ldx: *const lapack_int,
rcond: *mut c_float,
berr: *mut c_float,
n_err_bnds: *const lapack_int,
err_bnds_norm: *mut c_float,
err_bnds_comp: *mut c_float,
nparams: *const lapack_int,
params: *mut c_float,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn cherfs_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
af: *const lapack_complex_float,
ldaf: *const lapack_int,
ipiv: *const lapack_int,
b: *const lapack_complex_float,
ldb: *const lapack_int,
x: *mut lapack_complex_float,
ldx: *const lapack_int,
ferr: *mut c_float,
berr: *mut c_float,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn zherfs_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
af: *const lapack_complex_double,
ldaf: *const lapack_int,
ipiv: *const lapack_int,
b: *const lapack_complex_double,
ldb: *const lapack_int,
x: *mut lapack_complex_double,
ldx: *const lapack_int,
ferr: *mut c_double,
berr: *mut c_double,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn zherfsx_(
uplo: *const c_char,
equed: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
af: *const lapack_complex_double,
ldaf: *const lapack_int,
ipiv: *const lapack_int,
s: *const c_double,
b: *const lapack_complex_double,
ldb: *const lapack_int,
x: *mut lapack_complex_double,
ldx: *const lapack_int,
rcond: *mut c_double,
berr: *mut c_double,
n_err_bnds: *const lapack_int,
err_bnds_norm: *mut c_double,
err_bnds_comp: *mut c_double,
nparams: *const lapack_int,
params: *mut c_double,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn cherfsx_(
uplo: *const c_char,
equed: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
af: *const lapack_complex_float,
ldaf: *const lapack_int,
ipiv: *const lapack_int,
s: *const c_float,
b: *const lapack_complex_float,
ldb: *const lapack_int,
x: *mut lapack_complex_float,
ldx: *const lapack_int,
rcond: *mut c_float,
berr: *mut c_float,
n_err_bnds: *const lapack_int,
err_bnds_norm: *mut c_float,
err_bnds_comp: *mut c_float,
nparams: *const lapack_int,
params: *mut c_float,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn ssprfs_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
ap: *const c_float,
afp: *const c_float,
ipiv: *const lapack_int,
b: *const c_float,
ldb: *const lapack_int,
x: *mut c_float,
ldx: *const lapack_int,
ferr: *mut c_float,
berr: *mut c_float,
work: *mut c_float,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dsprfs_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
ap: *const c_double,
afp: *const c_double,
ipiv: *const lapack_int,
b: *const c_double,
ldb: *const lapack_int,
x: *mut c_double,
ldx: *const lapack_int,
ferr: *mut c_double,
berr: *mut c_double,
work: *mut c_double,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn csprfs_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
ap: *const lapack_complex_float,
afp: *const lapack_complex_float,
ipiv: *const lapack_int,
b: *const lapack_complex_float,
ldb: *const lapack_int,
x: *mut lapack_complex_float,
ldx: *const lapack_int,
ferr: *mut c_float,
berr: *mut c_float,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn zsprfs_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
ap: *const lapack_complex_double,
afp: *const lapack_complex_double,
ipiv: *const lapack_int,
b: *const lapack_complex_double,
ldb: *const lapack_int,
x: *mut lapack_complex_double,
ldx: *const lapack_int,
ferr: *mut c_double,
berr: *mut c_double,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn chprfs_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
ap: *const lapack_complex_float,
afp: *const lapack_complex_float,
ipiv: *const lapack_int,
b: *const lapack_complex_float,
ldb: *const lapack_int,
x: *mut lapack_complex_float,
ldx: *const lapack_int,
ferr: *mut c_float,
berr: *mut c_float,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn zhprfs_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
ap: *const lapack_complex_double,
afp: *const lapack_complex_double,
ipiv: *const lapack_int,
b: *const lapack_complex_double,
ldb: *const lapack_int,
x: *mut lapack_complex_double,
ldx: *const lapack_int,
ferr: *mut c_double,
berr: *mut c_double,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn strrfs_(
uplo: *const c_char,
trans: *const c_char,
diag: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const c_float,
lda: *const lapack_int,
b: *const c_float,
ldb: *const lapack_int,
x: *const c_float,
ldx: *const lapack_int,
ferr: *mut c_float,
berr: *mut c_float,
work: *mut c_float,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dtrrfs_(
uplo: *const c_char,
trans: *const c_char,
diag: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const c_double,
lda: *const lapack_int,
b: *const c_double,
ldb: *const lapack_int,
x: *const c_double,
ldx: *const lapack_int,
ferr: *mut c_double,
berr: *mut c_double,
work: *mut c_double,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn ctrrfs_(
uplo: *const c_char,
trans: *const c_char,
diag: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
b: *const lapack_complex_float,
ldb: *const lapack_int,
x: *const lapack_complex_float,
ldx: *const lapack_int,
ferr: *mut c_float,
berr: *mut c_float,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn ztrrfs_(
uplo: *const c_char,
trans: *const c_char,
diag: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
b: *const lapack_complex_double,
ldb: *const lapack_int,
x: *const lapack_complex_double,
ldx: *const lapack_int,
ferr: *mut c_double,
berr: *mut c_double,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn stprfs_(
uplo: *const c_char,
trans: *const c_char,
diag: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
ap: *const c_float,
b: *const c_float,
ldb: *const lapack_int,
x: *const c_float,
ldx: *const lapack_int,
ferr: *mut c_float,
berr: *mut c_float,
work: *mut c_float,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dtprfs_(
uplo: *const c_char,
trans: *const c_char,
diag: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
ap: *const c_double,
b: *const c_double,
ldb: *const lapack_int,
x: *const c_double,
ldx: *const lapack_int,
ferr: *mut c_double,
berr: *mut c_double,
work: *mut c_double,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn ctprfs_(
uplo: *const c_char,
trans: *const c_char,
diag: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
ap: *const lapack_complex_float,
b: *const lapack_complex_float,
ldb: *const lapack_int,
x: *const lapack_complex_float,
ldx: *const lapack_int,
ferr: *mut c_float,
berr: *mut c_float,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn ztprfs_(
uplo: *const c_char,
trans: *const c_char,
diag: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
ap: *const lapack_complex_double,
b: *const lapack_complex_double,
ldb: *const lapack_int,
x: *const lapack_complex_double,
ldx: *const lapack_int,
ferr: *mut c_double,
berr: *mut c_double,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn stbrfs_(
uplo: *const c_char,
trans: *const c_char,
diag: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
nrhs: *const lapack_int,
ab: *const c_float,
ldab: *const lapack_int,
b: *const c_float,
ldb: *const lapack_int,
x: *const c_float,
ldx: *const lapack_int,
ferr: *mut c_float,
berr: *mut c_float,
work: *mut c_float,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dtbrfs_(
uplo: *const c_char,
trans: *const c_char,
diag: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
nrhs: *const lapack_int,
ab: *const c_double,
ldab: *const lapack_int,
b: *const c_double,
ldb: *const lapack_int,
x: *const c_double,
ldx: *const lapack_int,
ferr: *mut c_double,
berr: *mut c_double,
work: *mut c_double,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn ctbrfs_(
uplo: *const c_char,
trans: *const c_char,
diag: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
nrhs: *const lapack_int,
ab: *const lapack_complex_float,
ldab: *const lapack_int,
b: *const lapack_complex_float,
ldb: *const lapack_int,
x: *const lapack_complex_float,
ldx: *const lapack_int,
ferr: *mut c_float,
berr: *mut c_float,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn ztbrfs_(
uplo: *const c_char,
trans: *const c_char,
diag: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
nrhs: *const lapack_int,
ab: *const lapack_complex_double,
ldab: *const lapack_int,
b: *const lapack_complex_double,
ldb: *const lapack_int,
x: *const lapack_complex_double,
ldx: *const lapack_int,
ferr: *mut c_double,
berr: *mut c_double,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn sgetri_(
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
ipiv: *const lapack_int,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dgetri_(
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
ipiv: *const lapack_int,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn cgetri_(
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
ipiv: *const lapack_int,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zgetri_(
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
ipiv: *const lapack_int,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn spotri_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
info: *mut lapack_int,
);
pub fn dpotri_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
info: *mut lapack_int,
);
pub fn cpotri_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
info: *mut lapack_int,
);
pub fn zpotri_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
info: *mut lapack_int,
);
pub fn dpftri_(
transr: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
a: *mut c_double,
info: *mut lapack_int,
);
pub fn spftri_(
transr: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
a: *mut c_float,
info: *mut lapack_int,
);
pub fn zpftri_(
transr: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_double,
info: *mut lapack_int,
);
pub fn cpftri_(
transr: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_float,
info: *mut lapack_int,
);
pub fn spptri_(
uplo: *const c_char,
n: *const lapack_int,
ap: *mut c_float,
info: *mut lapack_int,
);
pub fn dpptri_(
uplo: *const c_char,
n: *const lapack_int,
ap: *mut c_double,
info: *mut lapack_int,
);
pub fn cpptri_(
uplo: *const c_char,
n: *const lapack_int,
ap: *mut lapack_complex_float,
info: *mut lapack_int,
);
pub fn zpptri_(
uplo: *const c_char,
n: *const lapack_int,
ap: *mut lapack_complex_double,
info: *mut lapack_int,
);
pub fn ssytri_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
ipiv: *const lapack_int,
work: *mut c_float,
info: *mut lapack_int,
);
pub fn dsytri_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
ipiv: *const lapack_int,
work: *mut c_double,
info: *mut lapack_int,
);
pub fn csytri_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
ipiv: *const lapack_int,
work: *mut lapack_complex_float,
info: *mut lapack_int,
);
pub fn zsytri_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
ipiv: *const lapack_int,
work: *mut lapack_complex_double,
info: *mut lapack_int,
);
pub fn chetri_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
ipiv: *const lapack_int,
work: *mut lapack_complex_float,
info: *mut lapack_int,
);
pub fn zhetri_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
ipiv: *const lapack_int,
work: *mut lapack_complex_double,
info: *mut lapack_int,
);
pub fn ssptri_(
uplo: *const c_char,
n: *const lapack_int,
ap: *mut c_float,
ipiv: *const lapack_int,
work: *mut c_float,
info: *mut lapack_int,
);
pub fn dsptri_(
uplo: *const c_char,
n: *const lapack_int,
ap: *mut c_double,
ipiv: *const lapack_int,
work: *mut c_double,
info: *mut lapack_int,
);
pub fn csptri_(
uplo: *const c_char,
n: *const lapack_int,
ap: *mut lapack_complex_float,
ipiv: *const lapack_int,
work: *mut lapack_complex_float,
info: *mut lapack_int,
);
pub fn zsptri_(
uplo: *const c_char,
n: *const lapack_int,
ap: *mut lapack_complex_double,
ipiv: *const lapack_int,
work: *mut lapack_complex_double,
info: *mut lapack_int,
);
pub fn chptri_(
uplo: *const c_char,
n: *const lapack_int,
ap: *mut lapack_complex_float,
ipiv: *const lapack_int,
work: *mut lapack_complex_float,
info: *mut lapack_int,
);
pub fn zhptri_(
uplo: *const c_char,
n: *const lapack_int,
ap: *mut lapack_complex_double,
ipiv: *const lapack_int,
work: *mut lapack_complex_double,
info: *mut lapack_int,
);
pub fn strtri_(
uplo: *const c_char,
diag: *const c_char,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
info: *mut lapack_int,
);
pub fn dtrtri_(
uplo: *const c_char,
diag: *const c_char,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
info: *mut lapack_int,
);
pub fn ctrtri_(
uplo: *const c_char,
diag: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
info: *mut lapack_int,
);
pub fn ztrtri_(
uplo: *const c_char,
diag: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
info: *mut lapack_int,
);
pub fn dtftri_(
transr: *const c_char,
uplo: *const c_char,
diag: *const c_char,
n: *const lapack_int,
a: *mut c_double,
info: *mut lapack_int,
);
pub fn stftri_(
transr: *const c_char,
uplo: *const c_char,
diag: *const c_char,
n: *const lapack_int,
a: *mut c_float,
info: *mut lapack_int,
);
pub fn ztftri_(
transr: *const c_char,
uplo: *const c_char,
diag: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_double,
info: *mut lapack_int,
);
pub fn ctftri_(
transr: *const c_char,
uplo: *const c_char,
diag: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_float,
info: *mut lapack_int,
);
pub fn stptri_(
uplo: *const c_char,
diag: *const c_char,
n: *const lapack_int,
ap: *mut c_float,
info: *mut lapack_int,
);
pub fn dtptri_(
uplo: *const c_char,
diag: *const c_char,
n: *const lapack_int,
ap: *mut c_double,
info: *mut lapack_int,
);
pub fn ctptri_(
uplo: *const c_char,
diag: *const c_char,
n: *const lapack_int,
ap: *mut lapack_complex_float,
info: *mut lapack_int,
);
pub fn ztptri_(
uplo: *const c_char,
diag: *const c_char,
n: *const lapack_int,
ap: *mut lapack_complex_double,
info: *mut lapack_int,
);
pub fn sgeequ_(
m: *const lapack_int,
n: *const lapack_int,
a: *const c_float,
lda: *const lapack_int,
r: *mut c_float,
c: *mut c_float,
rowcnd: *mut c_float,
colcnd: *mut c_float,
amax: *mut c_float,
info: *mut lapack_int,
);
pub fn dgeequ_(
m: *const lapack_int,
n: *const lapack_int,
a: *const c_double,
lda: *const lapack_int,
r: *mut c_double,
c: *mut c_double,
rowcnd: *mut c_double,
colcnd: *mut c_double,
amax: *mut c_double,
info: *mut lapack_int,
);
pub fn cgeequ_(
m: *const lapack_int,
n: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
r: *mut c_float,
c: *mut c_float,
rowcnd: *mut c_float,
colcnd: *mut c_float,
amax: *mut c_float,
info: *mut lapack_int,
);
pub fn zgeequ_(
m: *const lapack_int,
n: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
r: *mut c_double,
c: *mut c_double,
rowcnd: *mut c_double,
colcnd: *mut c_double,
amax: *mut c_double,
info: *mut lapack_int,
);
pub fn dgeequb_(
m: *const lapack_int,
n: *const lapack_int,
a: *const c_double,
lda: *const lapack_int,
r: *mut c_double,
c: *mut c_double,
rowcnd: *mut c_double,
colcnd: *mut c_double,
amax: *mut c_double,
info: *mut lapack_int,
);
pub fn sgeequb_(
m: *const lapack_int,
n: *const lapack_int,
a: *const c_float,
lda: *const lapack_int,
r: *mut c_float,
c: *mut c_float,
rowcnd: *mut c_float,
colcnd: *mut c_float,
amax: *mut c_float,
info: *mut lapack_int,
);
pub fn zgeequb_(
m: *const lapack_int,
n: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
r: *mut c_double,
c: *mut c_double,
rowcnd: *mut c_double,
colcnd: *mut c_double,
amax: *mut c_double,
info: *mut lapack_int,
);
pub fn cgeequb_(
m: *const lapack_int,
n: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
r: *mut c_float,
c: *mut c_float,
rowcnd: *mut c_float,
colcnd: *mut c_float,
amax: *mut c_float,
info: *mut lapack_int,
);
pub fn sgbequ_(
m: *const lapack_int,
n: *const lapack_int,
kl: *const lapack_int,
ku: *const lapack_int,
ab: *const c_float,
ldab: *const lapack_int,
r: *mut c_float,
c: *mut c_float,
rowcnd: *mut c_float,
colcnd: *mut c_float,
amax: *mut c_float,
info: *mut lapack_int,
);
pub fn dgbequ_(
m: *const lapack_int,
n: *const lapack_int,
kl: *const lapack_int,
ku: *const lapack_int,
ab: *const c_double,
ldab: *const lapack_int,
r: *mut c_double,
c: *mut c_double,
rowcnd: *mut c_double,
colcnd: *mut c_double,
amax: *mut c_double,
info: *mut lapack_int,
);
pub fn cgbequ_(
m: *const lapack_int,
n: *const lapack_int,
kl: *const lapack_int,
ku: *const lapack_int,
ab: *const lapack_complex_float,
ldab: *const lapack_int,
r: *mut c_float,
c: *mut c_float,
rowcnd: *mut c_float,
colcnd: *mut c_float,
amax: *mut c_float,
info: *mut lapack_int,
);
pub fn zgbequ_(
m: *const lapack_int,
n: *const lapack_int,
kl: *const lapack_int,
ku: *const lapack_int,
ab: *const lapack_complex_double,
ldab: *const lapack_int,
r: *mut c_double,
c: *mut c_double,
rowcnd: *mut c_double,
colcnd: *mut c_double,
amax: *mut c_double,
info: *mut lapack_int,
);
pub fn dgbequb_(
m: *const lapack_int,
n: *const lapack_int,
kl: *const lapack_int,
ku: *const lapack_int,
ab: *const c_double,
ldab: *const lapack_int,
r: *mut c_double,
c: *mut c_double,
rowcnd: *mut c_double,
colcnd: *mut c_double,
amax: *mut c_double,
info: *mut lapack_int,
);
pub fn sgbequb_(
m: *const lapack_int,
n: *const lapack_int,
kl: *const lapack_int,
ku: *const lapack_int,
ab: *const c_float,
ldab: *const lapack_int,
r: *mut c_float,
c: *mut c_float,
rowcnd: *mut c_float,
colcnd: *mut c_float,
amax: *mut c_float,
info: *mut lapack_int,
);
pub fn zgbequb_(
m: *const lapack_int,
n: *const lapack_int,
kl: *const lapack_int,
ku: *const lapack_int,
ab: *const lapack_complex_double,
ldab: *const lapack_int,
r: *mut c_double,
c: *mut c_double,
rowcnd: *mut c_double,
colcnd: *mut c_double,
amax: *mut c_double,
info: *mut lapack_int,
);
pub fn cgbequb_(
m: *const lapack_int,
n: *const lapack_int,
kl: *const lapack_int,
ku: *const lapack_int,
ab: *const lapack_complex_float,
ldab: *const lapack_int,
r: *mut c_float,
c: *mut c_float,
rowcnd: *mut c_float,
colcnd: *mut c_float,
amax: *mut c_float,
info: *mut lapack_int,
);
pub fn spoequ_(
n: *const lapack_int,
a: *const c_float,
lda: *const lapack_int,
s: *mut c_float,
scond: *mut c_float,
amax: *mut c_float,
info: *mut lapack_int,
);
pub fn dpoequ_(
n: *const lapack_int,
a: *const c_double,
lda: *const lapack_int,
s: *mut c_double,
scond: *mut c_double,
amax: *mut c_double,
info: *mut lapack_int,
);
pub fn cpoequ_(
n: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
s: *mut c_float,
scond: *mut c_float,
amax: *mut c_float,
info: *mut lapack_int,
);
pub fn zpoequ_(
n: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
s: *mut c_double,
scond: *mut c_double,
amax: *mut c_double,
info: *mut lapack_int,
);
pub fn dpoequb_(
n: *const lapack_int,
a: *const c_double,
lda: *const lapack_int,
s: *mut c_double,
scond: *mut c_double,
amax: *mut c_double,
info: *mut lapack_int,
);
pub fn spoequb_(
n: *const lapack_int,
a: *const c_float,
lda: *const lapack_int,
s: *mut c_float,
scond: *mut c_float,
amax: *mut c_float,
info: *mut lapack_int,
);
pub fn zpoequb_(
n: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
s: *mut c_double,
scond: *mut c_double,
amax: *mut c_double,
info: *mut lapack_int,
);
pub fn cpoequb_(
n: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
s: *mut c_float,
scond: *mut c_float,
amax: *mut c_float,
info: *mut lapack_int,
);
pub fn sppequ_(
uplo: *const c_char,
n: *const lapack_int,
ap: *const c_float,
s: *mut c_float,
scond: *mut c_float,
amax: *mut c_float,
info: *mut lapack_int,
);
pub fn dppequ_(
uplo: *const c_char,
n: *const lapack_int,
ap: *const c_double,
s: *mut c_double,
scond: *mut c_double,
amax: *mut c_double,
info: *mut lapack_int,
);
pub fn cppequ_(
uplo: *const c_char,
n: *const lapack_int,
ap: *const lapack_complex_float,
s: *mut c_float,
scond: *mut c_float,
amax: *mut c_float,
info: *mut lapack_int,
);
pub fn zppequ_(
uplo: *const c_char,
n: *const lapack_int,
ap: *const lapack_complex_double,
s: *mut c_double,
scond: *mut c_double,
amax: *mut c_double,
info: *mut lapack_int,
);
pub fn spbequ_(
uplo: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
ab: *const c_float,
ldab: *const lapack_int,
s: *mut c_float,
scond: *mut c_float,
amax: *mut c_float,
info: *mut lapack_int,
);
pub fn dpbequ_(
uplo: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
ab: *const c_double,
ldab: *const lapack_int,
s: *mut c_double,
scond: *mut c_double,
amax: *mut c_double,
info: *mut lapack_int,
);
pub fn cpbequ_(
uplo: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
ab: *const lapack_complex_float,
ldab: *const lapack_int,
s: *mut c_float,
scond: *mut c_float,
amax: *mut c_float,
info: *mut lapack_int,
);
pub fn zpbequ_(
uplo: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
ab: *const lapack_complex_double,
ldab: *const lapack_int,
s: *mut c_double,
scond: *mut c_double,
amax: *mut c_double,
info: *mut lapack_int,
);
pub fn dsyequb_(
uplo: *const c_char,
n: *const lapack_int,
a: *const c_double,
lda: *const lapack_int,
s: *mut c_double,
scond: *mut c_double,
amax: *mut c_double,
work: *mut c_double,
info: *mut lapack_int,
);
pub fn ssyequb_(
uplo: *const c_char,
n: *const lapack_int,
a: *const c_float,
lda: *const lapack_int,
s: *mut c_float,
scond: *mut c_float,
amax: *mut c_float,
work: *mut c_float,
info: *mut lapack_int,
);
pub fn zsyequb_(
uplo: *const c_char,
n: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
s: *mut c_double,
scond: *mut c_double,
amax: *mut c_double,
work: *mut lapack_complex_double,
info: *mut lapack_int,
);
pub fn csyequb_(
uplo: *const c_char,
n: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
s: *mut c_float,
scond: *mut c_float,
amax: *mut c_float,
work: *mut lapack_complex_float,
info: *mut lapack_int,
);
pub fn zheequb_(
uplo: *const c_char,
n: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
s: *mut c_double,
scond: *mut c_double,
amax: *mut c_double,
work: *mut lapack_complex_double,
info: *mut lapack_int,
);
pub fn cheequb_(
uplo: *const c_char,
n: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
s: *mut c_float,
scond: *mut c_float,
amax: *mut c_float,
work: *mut lapack_complex_float,
info: *mut lapack_int,
);
pub fn sgesv_(
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
ipiv: *mut lapack_int,
b: *mut c_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn dgesv_(
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
ipiv: *mut lapack_int,
b: *mut c_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn cgesv_(
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
ipiv: *mut lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn zgesv_(
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
ipiv: *mut lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn dsgesv_(
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
ipiv: *mut lapack_int,
b: *const c_double,
ldb: *const lapack_int,
x: *mut c_double,
ldx: *const lapack_int,
work: *mut c_double,
swork: *mut c_float,
iter: *mut lapack_int,
info: *mut lapack_int,
);
pub fn zcgesv_(
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
ipiv: *mut lapack_int,
b: *const lapack_complex_double,
ldb: *const lapack_int,
x: *mut lapack_complex_double,
ldx: *const lapack_int,
work: *mut lapack_complex_double,
swork: *mut lapack_complex_float,
rwork: *mut c_double,
iter: *mut lapack_int,
info: *mut lapack_int,
);
pub fn sgesvx_(
fact: *const c_char,
trans: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
af: *mut c_float,
ldaf: *const lapack_int,
ipiv: *mut lapack_int,
equed: *mut c_char,
r: *mut c_float,
c: *mut c_float,
b: *mut c_float,
ldb: *const lapack_int,
x: *mut c_float,
ldx: *const lapack_int,
rcond: *mut c_float,
ferr: *mut c_float,
berr: *mut c_float,
work: *mut c_float,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dgesvx_(
fact: *const c_char,
trans: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
af: *mut c_double,
ldaf: *const lapack_int,
ipiv: *mut lapack_int,
equed: *mut c_char,
r: *mut c_double,
c: *mut c_double,
b: *mut c_double,
ldb: *const lapack_int,
x: *mut c_double,
ldx: *const lapack_int,
rcond: *mut c_double,
ferr: *mut c_double,
berr: *mut c_double,
work: *mut c_double,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn cgesvx_(
fact: *const c_char,
trans: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
af: *mut lapack_complex_float,
ldaf: *const lapack_int,
ipiv: *mut lapack_int,
equed: *mut c_char,
r: *mut c_float,
c: *mut c_float,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
x: *mut lapack_complex_float,
ldx: *const lapack_int,
rcond: *mut c_float,
ferr: *mut c_float,
berr: *mut c_float,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn zgesvx_(
fact: *const c_char,
trans: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
af: *mut lapack_complex_double,
ldaf: *const lapack_int,
ipiv: *mut lapack_int,
equed: *mut c_char,
r: *mut c_double,
c: *mut c_double,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
x: *mut lapack_complex_double,
ldx: *const lapack_int,
rcond: *mut c_double,
ferr: *mut c_double,
berr: *mut c_double,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn dgesvxx_(
fact: *const c_char,
trans: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
af: *mut c_double,
ldaf: *const lapack_int,
ipiv: *mut lapack_int,
equed: *mut c_char,
r: *mut c_double,
c: *mut c_double,
b: *mut c_double,
ldb: *const lapack_int,
x: *mut c_double,
ldx: *const lapack_int,
rcond: *mut c_double,
rpvgrw: *mut c_double,
berr: *mut c_double,
n_err_bnds: *const lapack_int,
err_bnds_norm: *mut c_double,
err_bnds_comp: *mut c_double,
nparams: *const lapack_int,
params: *mut c_double,
work: *mut c_double,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn sgesvxx_(
fact: *const c_char,
trans: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
af: *mut c_float,
ldaf: *const lapack_int,
ipiv: *mut lapack_int,
equed: *mut c_char,
r: *mut c_float,
c: *mut c_float,
b: *mut c_float,
ldb: *const lapack_int,
x: *mut c_float,
ldx: *const lapack_int,
rcond: *mut c_float,
rpvgrw: *mut c_float,
berr: *mut c_float,
n_err_bnds: *const lapack_int,
err_bnds_norm: *mut c_float,
err_bnds_comp: *mut c_float,
nparams: *const lapack_int,
params: *mut c_float,
work: *mut c_float,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn zgesvxx_(
fact: *const c_char,
trans: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
af: *mut lapack_complex_double,
ldaf: *const lapack_int,
ipiv: *mut lapack_int,
equed: *mut c_char,
r: *mut c_double,
c: *mut c_double,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
x: *mut lapack_complex_double,
ldx: *const lapack_int,
rcond: *mut c_double,
rpvgrw: *mut c_double,
berr: *mut c_double,
n_err_bnds: *const lapack_int,
err_bnds_norm: *mut c_double,
err_bnds_comp: *mut c_double,
nparams: *const lapack_int,
params: *mut c_double,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn cgesvxx_(
fact: *const c_char,
trans: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
af: *mut lapack_complex_float,
ldaf: *const lapack_int,
ipiv: *mut lapack_int,
equed: *mut c_char,
r: *mut c_float,
c: *mut c_float,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
x: *mut lapack_complex_float,
ldx: *const lapack_int,
rcond: *mut c_float,
rpvgrw: *mut c_float,
berr: *mut c_float,
n_err_bnds: *const lapack_int,
err_bnds_norm: *mut c_float,
err_bnds_comp: *mut c_float,
nparams: *const lapack_int,
params: *mut c_float,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn sgbsv_(
n: *const lapack_int,
kl: *const lapack_int,
ku: *const lapack_int,
nrhs: *const lapack_int,
ab: *mut c_float,
ldab: *const lapack_int,
ipiv: *mut lapack_int,
b: *mut c_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn dgbsv_(
n: *const lapack_int,
kl: *const lapack_int,
ku: *const lapack_int,
nrhs: *const lapack_int,
ab: *mut c_double,
ldab: *const lapack_int,
ipiv: *mut lapack_int,
b: *mut c_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn cgbsv_(
n: *const lapack_int,
kl: *const lapack_int,
ku: *const lapack_int,
nrhs: *const lapack_int,
ab: *mut lapack_complex_float,
ldab: *const lapack_int,
ipiv: *mut lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn zgbsv_(
n: *const lapack_int,
kl: *const lapack_int,
ku: *const lapack_int,
nrhs: *const lapack_int,
ab: *mut lapack_complex_double,
ldab: *const lapack_int,
ipiv: *mut lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn sgbsvx_(
fact: *const c_char,
trans: *const c_char,
n: *const lapack_int,
kl: *const lapack_int,
ku: *const lapack_int,
nrhs: *const lapack_int,
ab: *mut c_float,
ldab: *const lapack_int,
afb: *mut c_float,
ldafb: *const lapack_int,
ipiv: *mut lapack_int,
equed: *mut c_char,
r: *mut c_float,
c: *mut c_float,
b: *mut c_float,
ldb: *const lapack_int,
x: *mut c_float,
ldx: *const lapack_int,
rcond: *mut c_float,
ferr: *mut c_float,
berr: *mut c_float,
work: *mut c_float,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dgbsvx_(
fact: *const c_char,
trans: *const c_char,
n: *const lapack_int,
kl: *const lapack_int,
ku: *const lapack_int,
nrhs: *const lapack_int,
ab: *mut c_double,
ldab: *const lapack_int,
afb: *mut c_double,
ldafb: *const lapack_int,
ipiv: *mut lapack_int,
equed: *mut c_char,
r: *mut c_double,
c: *mut c_double,
b: *mut c_double,
ldb: *const lapack_int,
x: *mut c_double,
ldx: *const lapack_int,
rcond: *mut c_double,
ferr: *mut c_double,
berr: *mut c_double,
work: *mut c_double,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn cgbsvx_(
fact: *const c_char,
trans: *const c_char,
n: *const lapack_int,
kl: *const lapack_int,
ku: *const lapack_int,
nrhs: *const lapack_int,
ab: *mut lapack_complex_float,
ldab: *const lapack_int,
afb: *mut lapack_complex_float,
ldafb: *const lapack_int,
ipiv: *mut lapack_int,
equed: *mut c_char,
r: *mut c_float,
c: *mut c_float,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
x: *mut lapack_complex_float,
ldx: *const lapack_int,
rcond: *mut c_float,
ferr: *mut c_float,
berr: *mut c_float,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn zgbsvx_(
fact: *const c_char,
trans: *const c_char,
n: *const lapack_int,
kl: *const lapack_int,
ku: *const lapack_int,
nrhs: *const lapack_int,
ab: *mut lapack_complex_double,
ldab: *const lapack_int,
afb: *mut lapack_complex_double,
ldafb: *const lapack_int,
ipiv: *mut lapack_int,
equed: *mut c_char,
r: *mut c_double,
c: *mut c_double,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
x: *mut lapack_complex_double,
ldx: *const lapack_int,
rcond: *mut c_double,
ferr: *mut c_double,
berr: *mut c_double,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn dgbsvxx_(
fact: *const c_char,
trans: *const c_char,
n: *const lapack_int,
kl: *const lapack_int,
ku: *const lapack_int,
nrhs: *const lapack_int,
ab: *mut c_double,
ldab: *const lapack_int,
afb: *mut c_double,
ldafb: *const lapack_int,
ipiv: *mut lapack_int,
equed: *mut c_char,
r: *mut c_double,
c: *mut c_double,
b: *mut c_double,
ldb: *const lapack_int,
x: *mut c_double,
ldx: *const lapack_int,
rcond: *mut c_double,
rpvgrw: *mut c_double,
berr: *mut c_double,
n_err_bnds: *const lapack_int,
err_bnds_norm: *mut c_double,
err_bnds_comp: *mut c_double,
nparams: *const lapack_int,
params: *mut c_double,
work: *mut c_double,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn sgbsvxx_(
fact: *const c_char,
trans: *const c_char,
n: *const lapack_int,
kl: *const lapack_int,
ku: *const lapack_int,
nrhs: *const lapack_int,
ab: *mut c_float,
ldab: *const lapack_int,
afb: *mut c_float,
ldafb: *const lapack_int,
ipiv: *mut lapack_int,
equed: *mut c_char,
r: *mut c_float,
c: *mut c_float,
b: *mut c_float,
ldb: *const lapack_int,
x: *mut c_float,
ldx: *const lapack_int,
rcond: *mut c_float,
rpvgrw: *mut c_float,
berr: *mut c_float,
n_err_bnds: *const lapack_int,
err_bnds_norm: *mut c_float,
err_bnds_comp: *mut c_float,
nparams: *const lapack_int,
params: *mut c_float,
work: *mut c_float,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn zgbsvxx_(
fact: *const c_char,
trans: *const c_char,
n: *const lapack_int,
kl: *const lapack_int,
ku: *const lapack_int,
nrhs: *const lapack_int,
ab: *mut lapack_complex_double,
ldab: *const lapack_int,
afb: *mut lapack_complex_double,
ldafb: *const lapack_int,
ipiv: *mut lapack_int,
equed: *mut c_char,
r: *mut c_double,
c: *mut c_double,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
x: *mut lapack_complex_double,
ldx: *const lapack_int,
rcond: *mut c_double,
rpvgrw: *mut c_double,
berr: *mut c_double,
n_err_bnds: *const lapack_int,
err_bnds_norm: *mut c_double,
err_bnds_comp: *mut c_double,
nparams: *const lapack_int,
params: *mut c_double,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn cgbsvxx_(
fact: *const c_char,
trans: *const c_char,
n: *const lapack_int,
kl: *const lapack_int,
ku: *const lapack_int,
nrhs: *const lapack_int,
ab: *mut lapack_complex_float,
ldab: *const lapack_int,
afb: *mut lapack_complex_float,
ldafb: *const lapack_int,
ipiv: *mut lapack_int,
equed: *mut c_char,
r: *mut c_float,
c: *mut c_float,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
x: *mut lapack_complex_float,
ldx: *const lapack_int,
rcond: *mut c_float,
rpvgrw: *mut c_float,
berr: *mut c_float,
n_err_bnds: *const lapack_int,
err_bnds_norm: *mut c_float,
err_bnds_comp: *mut c_float,
nparams: *const lapack_int,
params: *mut c_float,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn sgtsv_(
n: *const lapack_int,
nrhs: *const lapack_int,
dl: *mut c_float,
d: *mut c_float,
du: *mut c_float,
b: *mut c_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn dgtsv_(
n: *const lapack_int,
nrhs: *const lapack_int,
dl: *mut c_double,
d: *mut c_double,
du: *mut c_double,
b: *mut c_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn cgtsv_(
n: *const lapack_int,
nrhs: *const lapack_int,
dl: *mut lapack_complex_float,
d: *mut lapack_complex_float,
du: *mut lapack_complex_float,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn zgtsv_(
n: *const lapack_int,
nrhs: *const lapack_int,
dl: *mut lapack_complex_double,
d: *mut lapack_complex_double,
du: *mut lapack_complex_double,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn sgtsvx_(
fact: *const c_char,
trans: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
dl: *const c_float,
d: *const c_float,
du: *const c_float,
dlf: *mut c_float,
df: *mut c_float,
duf: *mut c_float,
du2: *mut c_float,
ipiv: *mut lapack_int,
b: *const c_float,
ldb: *const lapack_int,
x: *mut c_float,
ldx: *const lapack_int,
rcond: *mut c_float,
ferr: *mut c_float,
berr: *mut c_float,
work: *mut c_float,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dgtsvx_(
fact: *const c_char,
trans: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
dl: *const c_double,
d: *const c_double,
du: *const c_double,
dlf: *mut c_double,
df: *mut c_double,
duf: *mut c_double,
du2: *mut c_double,
ipiv: *mut lapack_int,
b: *const c_double,
ldb: *const lapack_int,
x: *mut c_double,
ldx: *const lapack_int,
rcond: *mut c_double,
ferr: *mut c_double,
berr: *mut c_double,
work: *mut c_double,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn cgtsvx_(
fact: *const c_char,
trans: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
dl: *const lapack_complex_float,
d: *const lapack_complex_float,
du: *const lapack_complex_float,
dlf: *mut lapack_complex_float,
df: *mut lapack_complex_float,
duf: *mut lapack_complex_float,
du2: *mut lapack_complex_float,
ipiv: *mut lapack_int,
b: *const lapack_complex_float,
ldb: *const lapack_int,
x: *mut lapack_complex_float,
ldx: *const lapack_int,
rcond: *mut c_float,
ferr: *mut c_float,
berr: *mut c_float,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn zgtsvx_(
fact: *const c_char,
trans: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
dl: *const lapack_complex_double,
d: *const lapack_complex_double,
du: *const lapack_complex_double,
dlf: *mut lapack_complex_double,
df: *mut lapack_complex_double,
duf: *mut lapack_complex_double,
du2: *mut lapack_complex_double,
ipiv: *mut lapack_int,
b: *const lapack_complex_double,
ldb: *const lapack_int,
x: *mut lapack_complex_double,
ldx: *const lapack_int,
rcond: *mut c_double,
ferr: *mut c_double,
berr: *mut c_double,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn sposv_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
b: *mut c_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn dposv_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
b: *mut c_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn cposv_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn zposv_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn dsposv_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
b: *const c_double,
ldb: *const lapack_int,
x: *mut c_double,
ldx: *const lapack_int,
work: *mut c_double,
swork: *mut c_float,
iter: *mut lapack_int,
info: *mut lapack_int,
);
pub fn zcposv_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
b: *const lapack_complex_double,
ldb: *const lapack_int,
x: *mut lapack_complex_double,
ldx: *const lapack_int,
work: *mut lapack_complex_double,
swork: *mut lapack_complex_float,
rwork: *mut c_double,
iter: *mut lapack_int,
info: *mut lapack_int,
);
pub fn sposvx_(
fact: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
af: *mut c_float,
ldaf: *const lapack_int,
equed: *mut c_char,
s: *mut c_float,
b: *mut c_float,
ldb: *const lapack_int,
x: *mut c_float,
ldx: *const lapack_int,
rcond: *mut c_float,
ferr: *mut c_float,
berr: *mut c_float,
work: *mut c_float,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dposvx_(
fact: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
af: *mut c_double,
ldaf: *const lapack_int,
equed: *mut c_char,
s: *mut c_double,
b: *mut c_double,
ldb: *const lapack_int,
x: *mut c_double,
ldx: *const lapack_int,
rcond: *mut c_double,
ferr: *mut c_double,
berr: *mut c_double,
work: *mut c_double,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn cposvx_(
fact: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
af: *mut lapack_complex_float,
ldaf: *const lapack_int,
equed: *mut c_char,
s: *mut c_float,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
x: *mut lapack_complex_float,
ldx: *const lapack_int,
rcond: *mut c_float,
ferr: *mut c_float,
berr: *mut c_float,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn zposvx_(
fact: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
af: *mut lapack_complex_double,
ldaf: *const lapack_int,
equed: *mut c_char,
s: *mut c_double,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
x: *mut lapack_complex_double,
ldx: *const lapack_int,
rcond: *mut c_double,
ferr: *mut c_double,
berr: *mut c_double,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn dposvxx_(
fact: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
af: *mut c_double,
ldaf: *const lapack_int,
equed: *mut c_char,
s: *mut c_double,
b: *mut c_double,
ldb: *const lapack_int,
x: *mut c_double,
ldx: *const lapack_int,
rcond: *mut c_double,
rpvgrw: *mut c_double,
berr: *mut c_double,
n_err_bnds: *const lapack_int,
err_bnds_norm: *mut c_double,
err_bnds_comp: *mut c_double,
nparams: *const lapack_int,
params: *mut c_double,
work: *mut c_double,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn sposvxx_(
fact: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
af: *mut c_float,
ldaf: *const lapack_int,
equed: *mut c_char,
s: *mut c_float,
b: *mut c_float,
ldb: *const lapack_int,
x: *mut c_float,
ldx: *const lapack_int,
rcond: *mut c_float,
rpvgrw: *mut c_float,
berr: *mut c_float,
n_err_bnds: *const lapack_int,
err_bnds_norm: *mut c_float,
err_bnds_comp: *mut c_float,
nparams: *const lapack_int,
params: *mut c_float,
work: *mut c_float,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn zposvxx_(
fact: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
af: *mut lapack_complex_double,
ldaf: *const lapack_int,
equed: *mut c_char,
s: *mut c_double,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
x: *mut lapack_complex_double,
ldx: *const lapack_int,
rcond: *mut c_double,
rpvgrw: *mut c_double,
berr: *mut c_double,
n_err_bnds: *const lapack_int,
err_bnds_norm: *mut c_double,
err_bnds_comp: *mut c_double,
nparams: *const lapack_int,
params: *mut c_double,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn cposvxx_(
fact: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
af: *mut lapack_complex_float,
ldaf: *const lapack_int,
equed: *mut c_char,
s: *mut c_float,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
x: *mut lapack_complex_float,
ldx: *const lapack_int,
rcond: *mut c_float,
rpvgrw: *mut c_float,
berr: *mut c_float,
n_err_bnds: *const lapack_int,
err_bnds_norm: *mut c_float,
err_bnds_comp: *mut c_float,
nparams: *const lapack_int,
params: *mut c_float,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn sppsv_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
ap: *mut c_float,
b: *mut c_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn dppsv_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
ap: *mut c_double,
b: *mut c_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn cppsv_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
ap: *mut lapack_complex_float,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn zppsv_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
ap: *mut lapack_complex_double,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn sppsvx_(
fact: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
ap: *mut c_float,
afp: *mut c_float,
equed: *mut c_char,
s: *mut c_float,
b: *mut c_float,
ldb: *const lapack_int,
x: *mut c_float,
ldx: *const lapack_int,
rcond: *mut c_float,
ferr: *mut c_float,
berr: *mut c_float,
work: *mut c_float,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dppsvx_(
fact: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
ap: *mut c_double,
afp: *mut c_double,
equed: *mut c_char,
s: *mut c_double,
b: *mut c_double,
ldb: *const lapack_int,
x: *mut c_double,
ldx: *const lapack_int,
rcond: *mut c_double,
ferr: *mut c_double,
berr: *mut c_double,
work: *mut c_double,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn cppsvx_(
fact: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
ap: *mut lapack_complex_float,
afp: *mut lapack_complex_float,
equed: *mut c_char,
s: *mut c_float,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
x: *mut lapack_complex_float,
ldx: *const lapack_int,
rcond: *mut c_float,
ferr: *mut c_float,
berr: *mut c_float,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn zppsvx_(
fact: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
ap: *mut lapack_complex_double,
afp: *mut lapack_complex_double,
equed: *mut c_char,
s: *mut c_double,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
x: *mut lapack_complex_double,
ldx: *const lapack_int,
rcond: *mut c_double,
ferr: *mut c_double,
berr: *mut c_double,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn spbsv_(
uplo: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
nrhs: *const lapack_int,
ab: *mut c_float,
ldab: *const lapack_int,
b: *mut c_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn dpbsv_(
uplo: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
nrhs: *const lapack_int,
ab: *mut c_double,
ldab: *const lapack_int,
b: *mut c_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn cpbsv_(
uplo: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
nrhs: *const lapack_int,
ab: *mut lapack_complex_float,
ldab: *const lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn zpbsv_(
uplo: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
nrhs: *const lapack_int,
ab: *mut lapack_complex_double,
ldab: *const lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn spbsvx_(
fact: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
nrhs: *const lapack_int,
ab: *mut c_float,
ldab: *const lapack_int,
afb: *mut c_float,
ldafb: *const lapack_int,
equed: *mut c_char,
s: *mut c_float,
b: *mut c_float,
ldb: *const lapack_int,
x: *mut c_float,
ldx: *const lapack_int,
rcond: *mut c_float,
ferr: *mut c_float,
berr: *mut c_float,
work: *mut c_float,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dpbsvx_(
fact: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
nrhs: *const lapack_int,
ab: *mut c_double,
ldab: *const lapack_int,
afb: *mut c_double,
ldafb: *const lapack_int,
equed: *mut c_char,
s: *mut c_double,
b: *mut c_double,
ldb: *const lapack_int,
x: *mut c_double,
ldx: *const lapack_int,
rcond: *mut c_double,
ferr: *mut c_double,
berr: *mut c_double,
work: *mut c_double,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn cpbsvx_(
fact: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
nrhs: *const lapack_int,
ab: *mut lapack_complex_float,
ldab: *const lapack_int,
afb: *mut lapack_complex_float,
ldafb: *const lapack_int,
equed: *mut c_char,
s: *mut c_float,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
x: *mut lapack_complex_float,
ldx: *const lapack_int,
rcond: *mut c_float,
ferr: *mut c_float,
berr: *mut c_float,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn zpbsvx_(
fact: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
nrhs: *const lapack_int,
ab: *mut lapack_complex_double,
ldab: *const lapack_int,
afb: *mut lapack_complex_double,
ldafb: *const lapack_int,
equed: *mut c_char,
s: *mut c_double,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
x: *mut lapack_complex_double,
ldx: *const lapack_int,
rcond: *mut c_double,
ferr: *mut c_double,
berr: *mut c_double,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn sptsv_(
n: *const lapack_int,
nrhs: *const lapack_int,
d: *mut c_float,
e: *mut c_float,
b: *mut c_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn dptsv_(
n: *const lapack_int,
nrhs: *const lapack_int,
d: *mut c_double,
e: *mut c_double,
b: *mut c_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn cptsv_(
n: *const lapack_int,
nrhs: *const lapack_int,
d: *mut c_float,
e: *mut lapack_complex_float,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn zptsv_(
n: *const lapack_int,
nrhs: *const lapack_int,
d: *mut c_double,
e: *mut lapack_complex_double,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn sptsvx_(
fact: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
d: *const c_float,
e: *const c_float,
df: *mut c_float,
ef: *mut c_float,
b: *const c_float,
ldb: *const lapack_int,
x: *mut c_float,
ldx: *const lapack_int,
rcond: *mut c_float,
ferr: *mut c_float,
berr: *mut c_float,
work: *mut c_float,
info: *mut lapack_int,
);
pub fn dptsvx_(
fact: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
d: *const c_double,
e: *const c_double,
df: *mut c_double,
ef: *mut c_double,
b: *const c_double,
ldb: *const lapack_int,
x: *mut c_double,
ldx: *const lapack_int,
rcond: *mut c_double,
ferr: *mut c_double,
berr: *mut c_double,
work: *mut c_double,
info: *mut lapack_int,
);
pub fn cptsvx_(
fact: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
d: *const c_float,
e: *const lapack_complex_float,
df: *mut c_float,
ef: *mut lapack_complex_float,
b: *const lapack_complex_float,
ldb: *const lapack_int,
x: *mut lapack_complex_float,
ldx: *const lapack_int,
rcond: *mut c_float,
ferr: *mut c_float,
berr: *mut c_float,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn zptsvx_(
fact: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
d: *const c_double,
e: *const lapack_complex_double,
df: *mut c_double,
ef: *mut lapack_complex_double,
b: *const lapack_complex_double,
ldb: *const lapack_int,
x: *mut lapack_complex_double,
ldx: *const lapack_int,
rcond: *mut c_double,
ferr: *mut c_double,
berr: *mut c_double,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn ssysv_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
ipiv: *mut lapack_int,
b: *mut c_float,
ldb: *const lapack_int,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dsysv_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
ipiv: *mut lapack_int,
b: *mut c_double,
ldb: *const lapack_int,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn csysv_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
ipiv: *mut lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zsysv_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
ipiv: *mut lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn ssysvx_(
fact: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const c_float,
lda: *const lapack_int,
af: *mut c_float,
ldaf: *const lapack_int,
ipiv: *mut lapack_int,
b: *const c_float,
ldb: *const lapack_int,
x: *mut c_float,
ldx: *const lapack_int,
rcond: *mut c_float,
ferr: *mut c_float,
berr: *mut c_float,
work: *mut c_float,
lwork: *const lapack_int,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dsysvx_(
fact: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const c_double,
lda: *const lapack_int,
af: *mut c_double,
ldaf: *const lapack_int,
ipiv: *mut lapack_int,
b: *const c_double,
ldb: *const lapack_int,
x: *mut c_double,
ldx: *const lapack_int,
rcond: *mut c_double,
ferr: *mut c_double,
berr: *mut c_double,
work: *mut c_double,
lwork: *const lapack_int,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn csysvx_(
fact: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
af: *mut lapack_complex_float,
ldaf: *const lapack_int,
ipiv: *mut lapack_int,
b: *const lapack_complex_float,
ldb: *const lapack_int,
x: *mut lapack_complex_float,
ldx: *const lapack_int,
rcond: *mut c_float,
ferr: *mut c_float,
berr: *mut c_float,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn zsysvx_(
fact: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
af: *mut lapack_complex_double,
ldaf: *const lapack_int,
ipiv: *mut lapack_int,
b: *const lapack_complex_double,
ldb: *const lapack_int,
x: *mut lapack_complex_double,
ldx: *const lapack_int,
rcond: *mut c_double,
ferr: *mut c_double,
berr: *mut c_double,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn dsysvxx_(
fact: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
af: *mut c_double,
ldaf: *const lapack_int,
ipiv: *mut lapack_int,
equed: *mut c_char,
s: *mut c_double,
b: *mut c_double,
ldb: *const lapack_int,
x: *mut c_double,
ldx: *const lapack_int,
rcond: *mut c_double,
rpvgrw: *mut c_double,
berr: *mut c_double,
n_err_bnds: *const lapack_int,
err_bnds_norm: *mut c_double,
err_bnds_comp: *mut c_double,
nparams: *const lapack_int,
params: *mut c_double,
work: *mut c_double,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn ssysvxx_(
fact: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
af: *mut c_float,
ldaf: *const lapack_int,
ipiv: *mut lapack_int,
equed: *mut c_char,
s: *mut c_float,
b: *mut c_float,
ldb: *const lapack_int,
x: *mut c_float,
ldx: *const lapack_int,
rcond: *mut c_float,
rpvgrw: *mut c_float,
berr: *mut c_float,
n_err_bnds: *const lapack_int,
err_bnds_norm: *mut c_float,
err_bnds_comp: *mut c_float,
nparams: *const lapack_int,
params: *mut c_float,
work: *mut c_float,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn zsysvxx_(
fact: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
af: *mut lapack_complex_double,
ldaf: *const lapack_int,
ipiv: *mut lapack_int,
equed: *mut c_char,
s: *mut c_double,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
x: *mut lapack_complex_double,
ldx: *const lapack_int,
rcond: *mut c_double,
rpvgrw: *mut c_double,
berr: *mut c_double,
n_err_bnds: *const lapack_int,
err_bnds_norm: *mut c_double,
err_bnds_comp: *mut c_double,
nparams: *const lapack_int,
params: *mut c_double,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn csysvxx_(
fact: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
af: *mut lapack_complex_float,
ldaf: *const lapack_int,
ipiv: *mut lapack_int,
equed: *mut c_char,
s: *mut c_float,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
x: *mut lapack_complex_float,
ldx: *const lapack_int,
rcond: *mut c_float,
rpvgrw: *mut c_float,
berr: *mut c_float,
n_err_bnds: *const lapack_int,
err_bnds_norm: *mut c_float,
err_bnds_comp: *mut c_float,
nparams: *const lapack_int,
params: *mut c_float,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn chesv_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
ipiv: *mut lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zhesv_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
ipiv: *mut lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn chesvx_(
fact: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
af: *mut lapack_complex_float,
ldaf: *const lapack_int,
ipiv: *mut lapack_int,
b: *const lapack_complex_float,
ldb: *const lapack_int,
x: *mut lapack_complex_float,
ldx: *const lapack_int,
rcond: *mut c_float,
ferr: *mut c_float,
berr: *mut c_float,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn zhesvx_(
fact: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
af: *mut lapack_complex_double,
ldaf: *const lapack_int,
ipiv: *mut lapack_int,
b: *const lapack_complex_double,
ldb: *const lapack_int,
x: *mut lapack_complex_double,
ldx: *const lapack_int,
rcond: *mut c_double,
ferr: *mut c_double,
berr: *mut c_double,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn zhesvxx_(
fact: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
af: *mut lapack_complex_double,
ldaf: *const lapack_int,
ipiv: *mut lapack_int,
equed: *mut c_char,
s: *mut c_double,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
x: *mut lapack_complex_double,
ldx: *const lapack_int,
rcond: *mut c_double,
rpvgrw: *mut c_double,
berr: *mut c_double,
n_err_bnds: *const lapack_int,
err_bnds_norm: *mut c_double,
err_bnds_comp: *mut c_double,
nparams: *const lapack_int,
params: *mut c_double,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn chesvxx_(
fact: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
af: *mut lapack_complex_float,
ldaf: *const lapack_int,
ipiv: *mut lapack_int,
equed: *mut c_char,
s: *mut c_float,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
x: *mut lapack_complex_float,
ldx: *const lapack_int,
rcond: *mut c_float,
rpvgrw: *mut c_float,
berr: *mut c_float,
n_err_bnds: *const lapack_int,
err_bnds_norm: *mut c_float,
err_bnds_comp: *mut c_float,
nparams: *const lapack_int,
params: *mut c_float,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn sspsv_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
ap: *mut c_float,
ipiv: *mut lapack_int,
b: *mut c_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn dspsv_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
ap: *mut c_double,
ipiv: *mut lapack_int,
b: *mut c_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn cspsv_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
ap: *mut lapack_complex_float,
ipiv: *mut lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn zspsv_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
ap: *mut lapack_complex_double,
ipiv: *mut lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn sspsvx_(
fact: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
ap: *const c_float,
afp: *mut c_float,
ipiv: *mut lapack_int,
b: *const c_float,
ldb: *const lapack_int,
x: *mut c_float,
ldx: *const lapack_int,
rcond: *mut c_float,
ferr: *mut c_float,
berr: *mut c_float,
work: *mut c_float,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dspsvx_(
fact: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
ap: *const c_double,
afp: *mut c_double,
ipiv: *mut lapack_int,
b: *const c_double,
ldb: *const lapack_int,
x: *mut c_double,
ldx: *const lapack_int,
rcond: *mut c_double,
ferr: *mut c_double,
berr: *mut c_double,
work: *mut c_double,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn cspsvx_(
fact: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
ap: *const lapack_complex_float,
afp: *mut lapack_complex_float,
ipiv: *mut lapack_int,
b: *const lapack_complex_float,
ldb: *const lapack_int,
x: *mut lapack_complex_float,
ldx: *const lapack_int,
rcond: *mut c_float,
ferr: *mut c_float,
berr: *mut c_float,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn zspsvx_(
fact: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
ap: *const lapack_complex_double,
afp: *mut lapack_complex_double,
ipiv: *mut lapack_int,
b: *const lapack_complex_double,
ldb: *const lapack_int,
x: *mut lapack_complex_double,
ldx: *const lapack_int,
rcond: *mut c_double,
ferr: *mut c_double,
berr: *mut c_double,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn chpsv_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
ap: *mut lapack_complex_float,
ipiv: *mut lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn zhpsv_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
ap: *mut lapack_complex_double,
ipiv: *mut lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn chpsvx_(
fact: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
ap: *const lapack_complex_float,
afp: *mut lapack_complex_float,
ipiv: *mut lapack_int,
b: *const lapack_complex_float,
ldb: *const lapack_int,
x: *mut lapack_complex_float,
ldx: *const lapack_int,
rcond: *mut c_float,
ferr: *mut c_float,
berr: *mut c_float,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn zhpsvx_(
fact: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
ap: *const lapack_complex_double,
afp: *mut lapack_complex_double,
ipiv: *mut lapack_int,
b: *const lapack_complex_double,
ldb: *const lapack_int,
x: *mut lapack_complex_double,
ldx: *const lapack_int,
rcond: *mut c_double,
ferr: *mut c_double,
berr: *mut c_double,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn sgeqrf_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
tau: *mut c_float,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dgeqrf_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
tau: *mut c_double,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn cgeqrf_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
tau: *mut lapack_complex_float,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zgeqrf_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
tau: *mut lapack_complex_double,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn sgeqpf_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
jpvt: *mut lapack_int,
tau: *mut c_float,
work: *mut c_float,
info: *mut lapack_int,
);
pub fn dgeqpf_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
jpvt: *mut lapack_int,
tau: *mut c_double,
work: *mut c_double,
info: *mut lapack_int,
);
pub fn cgeqpf_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
jpvt: *mut lapack_int,
tau: *mut lapack_complex_float,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn zgeqpf_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
jpvt: *mut lapack_int,
tau: *mut lapack_complex_double,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn sgeqp3_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
jpvt: *mut lapack_int,
tau: *mut c_float,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dgeqp3_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
jpvt: *mut lapack_int,
tau: *mut c_double,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn cgeqp3_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
jpvt: *mut lapack_int,
tau: *mut lapack_complex_float,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn zgeqp3_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
jpvt: *mut lapack_int,
tau: *mut lapack_complex_double,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn sorgqr_(
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
tau: *const c_float,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dorgqr_(
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
tau: *const c_double,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn sormqr_(
side: *const c_char,
trans: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
a: *const c_float,
lda: *const lapack_int,
tau: *const c_float,
c: *mut c_float,
ldc: *const lapack_int,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dormqr_(
side: *const c_char,
trans: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
a: *const c_double,
lda: *const lapack_int,
tau: *const c_double,
c: *mut c_double,
ldc: *const lapack_int,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn cungqr_(
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
tau: *const lapack_complex_float,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zungqr_(
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
tau: *const lapack_complex_double,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn cunmqr_(
side: *const c_char,
trans: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
tau: *const lapack_complex_float,
c: *mut lapack_complex_float,
ldc: *const lapack_int,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zunmqr_(
side: *const c_char,
trans: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
tau: *const lapack_complex_double,
c: *mut lapack_complex_double,
ldc: *const lapack_int,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn sgelqf_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
tau: *mut c_float,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dgelqf_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
tau: *mut c_double,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn cgelqf_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
tau: *mut lapack_complex_float,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zgelqf_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
tau: *mut lapack_complex_double,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn sorglq_(
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
tau: *const c_float,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dorglq_(
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
tau: *const c_double,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn sormlq_(
side: *const c_char,
trans: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
a: *const c_float,
lda: *const lapack_int,
tau: *const c_float,
c: *mut c_float,
ldc: *const lapack_int,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dormlq_(
side: *const c_char,
trans: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
a: *const c_double,
lda: *const lapack_int,
tau: *const c_double,
c: *mut c_double,
ldc: *const lapack_int,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn cunglq_(
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
tau: *const lapack_complex_float,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zunglq_(
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
tau: *const lapack_complex_double,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn cunmlq_(
side: *const c_char,
trans: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
tau: *const lapack_complex_float,
c: *mut lapack_complex_float,
ldc: *const lapack_int,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zunmlq_(
side: *const c_char,
trans: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
tau: *const lapack_complex_double,
c: *mut lapack_complex_double,
ldc: *const lapack_int,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn sgeqlf_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
tau: *mut c_float,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dgeqlf_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
tau: *mut c_double,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn cgeqlf_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
tau: *mut lapack_complex_float,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zgeqlf_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
tau: *mut lapack_complex_double,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn sorgql_(
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
tau: *const c_float,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dorgql_(
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
tau: *const c_double,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn cungql_(
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
tau: *const lapack_complex_float,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zungql_(
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
tau: *const lapack_complex_double,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn sormql_(
side: *const c_char,
trans: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
a: *const c_float,
lda: *const lapack_int,
tau: *const c_float,
c: *mut c_float,
ldc: *const lapack_int,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dormql_(
side: *const c_char,
trans: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
a: *const c_double,
lda: *const lapack_int,
tau: *const c_double,
c: *mut c_double,
ldc: *const lapack_int,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn cunmql_(
side: *const c_char,
trans: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
tau: *const lapack_complex_float,
c: *mut lapack_complex_float,
ldc: *const lapack_int,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zunmql_(
side: *const c_char,
trans: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
tau: *const lapack_complex_double,
c: *mut lapack_complex_double,
ldc: *const lapack_int,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn sgerqf_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
tau: *mut c_float,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dgerqf_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
tau: *mut c_double,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn cgerqf_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
tau: *mut lapack_complex_float,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zgerqf_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
tau: *mut lapack_complex_double,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn sorgrq_(
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
tau: *const c_float,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dorgrq_(
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
tau: *const c_double,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn cungrq_(
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
tau: *const lapack_complex_float,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zungrq_(
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
tau: *const lapack_complex_double,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn sormrq_(
side: *const c_char,
trans: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
a: *const c_float,
lda: *const lapack_int,
tau: *const c_float,
c: *mut c_float,
ldc: *const lapack_int,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dormrq_(
side: *const c_char,
trans: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
a: *const c_double,
lda: *const lapack_int,
tau: *const c_double,
c: *mut c_double,
ldc: *const lapack_int,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn cunmrq_(
side: *const c_char,
trans: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
tau: *const lapack_complex_float,
c: *mut lapack_complex_float,
ldc: *const lapack_int,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zunmrq_(
side: *const c_char,
trans: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
tau: *const lapack_complex_double,
c: *mut lapack_complex_double,
ldc: *const lapack_int,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn stzrzf_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
tau: *mut c_float,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dtzrzf_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
tau: *mut c_double,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn ctzrzf_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
tau: *mut lapack_complex_float,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn ztzrzf_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
tau: *mut lapack_complex_double,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn sormrz_(
side: *const c_char,
trans: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
l: *const lapack_int,
a: *const c_float,
lda: *const lapack_int,
tau: *const c_float,
c: *mut c_float,
ldc: *const lapack_int,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dormrz_(
side: *const c_char,
trans: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
l: *const lapack_int,
a: *const c_double,
lda: *const lapack_int,
tau: *const c_double,
c: *mut c_double,
ldc: *const lapack_int,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn cunmrz_(
side: *const c_char,
trans: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
l: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
tau: *const lapack_complex_float,
c: *mut lapack_complex_float,
ldc: *const lapack_int,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zunmrz_(
side: *const c_char,
trans: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
l: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
tau: *const lapack_complex_double,
c: *mut lapack_complex_double,
ldc: *const lapack_int,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn sggqrf_(
n: *const lapack_int,
m: *const lapack_int,
p: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
taua: *mut c_float,
b: *mut c_float,
ldb: *const lapack_int,
taub: *mut c_float,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dggqrf_(
n: *const lapack_int,
m: *const lapack_int,
p: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
taua: *mut c_double,
b: *mut c_double,
ldb: *const lapack_int,
taub: *mut c_double,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn cggqrf_(
n: *const lapack_int,
m: *const lapack_int,
p: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
taua: *mut lapack_complex_float,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
taub: *mut lapack_complex_float,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zggqrf_(
n: *const lapack_int,
m: *const lapack_int,
p: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
taua: *mut lapack_complex_double,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
taub: *mut lapack_complex_double,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn sggrqf_(
m: *const lapack_int,
p: *const lapack_int,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
taua: *mut c_float,
b: *mut c_float,
ldb: *const lapack_int,
taub: *mut c_float,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dggrqf_(
m: *const lapack_int,
p: *const lapack_int,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
taua: *mut c_double,
b: *mut c_double,
ldb: *const lapack_int,
taub: *mut c_double,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn cggrqf_(
m: *const lapack_int,
p: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
taua: *mut lapack_complex_float,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
taub: *mut lapack_complex_float,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zggrqf_(
m: *const lapack_int,
p: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
taua: *mut lapack_complex_double,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
taub: *mut lapack_complex_double,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn sgebrd_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
d: *mut c_float,
e: *mut c_float,
tauq: *mut c_float,
taup: *mut c_float,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dgebrd_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
d: *mut c_double,
e: *mut c_double,
tauq: *mut c_double,
taup: *mut c_double,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn cgebrd_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
d: *mut c_float,
e: *mut c_float,
tauq: *mut lapack_complex_float,
taup: *mut lapack_complex_float,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zgebrd_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
d: *mut c_double,
e: *mut c_double,
tauq: *mut lapack_complex_double,
taup: *mut lapack_complex_double,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn sgbbrd_(
vect: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
ncc: *const lapack_int,
kl: *const lapack_int,
ku: *const lapack_int,
ab: *mut c_float,
ldab: *const lapack_int,
d: *mut c_float,
e: *mut c_float,
q: *mut c_float,
ldq: *const lapack_int,
pt: *mut c_float,
ldpt: *const lapack_int,
c: *mut c_float,
ldc: *const lapack_int,
work: *mut c_float,
info: *mut lapack_int,
);
pub fn dgbbrd_(
vect: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
ncc: *const lapack_int,
kl: *const lapack_int,
ku: *const lapack_int,
ab: *mut c_double,
ldab: *const lapack_int,
d: *mut c_double,
e: *mut c_double,
q: *mut c_double,
ldq: *const lapack_int,
pt: *mut c_double,
ldpt: *const lapack_int,
c: *mut c_double,
ldc: *const lapack_int,
work: *mut c_double,
info: *mut lapack_int,
);
pub fn cgbbrd_(
vect: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
ncc: *const lapack_int,
kl: *const lapack_int,
ku: *const lapack_int,
ab: *mut lapack_complex_float,
ldab: *const lapack_int,
d: *mut c_float,
e: *mut c_float,
q: *mut lapack_complex_float,
ldq: *const lapack_int,
pt: *mut lapack_complex_float,
ldpt: *const lapack_int,
c: *mut lapack_complex_float,
ldc: *const lapack_int,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn zgbbrd_(
vect: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
ncc: *const lapack_int,
kl: *const lapack_int,
ku: *const lapack_int,
ab: *mut lapack_complex_double,
ldab: *const lapack_int,
d: *mut c_double,
e: *mut c_double,
q: *mut lapack_complex_double,
ldq: *const lapack_int,
pt: *mut lapack_complex_double,
ldpt: *const lapack_int,
c: *mut lapack_complex_double,
ldc: *const lapack_int,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn sorgbr_(
vect: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
tau: *const c_float,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dorgbr_(
vect: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
tau: *const c_double,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn sormbr_(
vect: *const c_char,
side: *const c_char,
trans: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
a: *const c_float,
lda: *const lapack_int,
tau: *const c_float,
c: *mut c_float,
ldc: *const lapack_int,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dormbr_(
vect: *const c_char,
side: *const c_char,
trans: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
a: *const c_double,
lda: *const lapack_int,
tau: *const c_double,
c: *mut c_double,
ldc: *const lapack_int,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn cungbr_(
vect: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
tau: *const lapack_complex_float,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zungbr_(
vect: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
tau: *const lapack_complex_double,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn cunmbr_(
vect: *const c_char,
side: *const c_char,
trans: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
tau: *const lapack_complex_float,
c: *mut lapack_complex_float,
ldc: *const lapack_int,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zunmbr_(
vect: *const c_char,
side: *const c_char,
trans: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
tau: *const lapack_complex_double,
c: *mut lapack_complex_double,
ldc: *const lapack_int,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn sbdsqr_(
uplo: *const c_char,
n: *const lapack_int,
ncvt: *const lapack_int,
nru: *const lapack_int,
ncc: *const lapack_int,
d: *mut c_float,
e: *mut c_float,
vt: *mut c_float,
ldvt: *const lapack_int,
u: *mut c_float,
ldu: *const lapack_int,
c: *mut c_float,
ldc: *const lapack_int,
work: *mut c_float,
info: *mut lapack_int,
);
pub fn dbdsqr_(
uplo: *const c_char,
n: *const lapack_int,
ncvt: *const lapack_int,
nru: *const lapack_int,
ncc: *const lapack_int,
d: *mut c_double,
e: *mut c_double,
vt: *mut c_double,
ldvt: *const lapack_int,
u: *mut c_double,
ldu: *const lapack_int,
c: *mut c_double,
ldc: *const lapack_int,
work: *mut c_double,
info: *mut lapack_int,
);
pub fn cbdsqr_(
uplo: *const c_char,
n: *const lapack_int,
ncvt: *const lapack_int,
nru: *const lapack_int,
ncc: *const lapack_int,
d: *mut c_float,
e: *mut c_float,
vt: *mut lapack_complex_float,
ldvt: *const lapack_int,
u: *mut lapack_complex_float,
ldu: *const lapack_int,
c: *mut lapack_complex_float,
ldc: *const lapack_int,
work: *mut c_float,
info: *mut lapack_int,
);
pub fn zbdsqr_(
uplo: *const c_char,
n: *const lapack_int,
ncvt: *const lapack_int,
nru: *const lapack_int,
ncc: *const lapack_int,
d: *mut c_double,
e: *mut c_double,
vt: *mut lapack_complex_double,
ldvt: *const lapack_int,
u: *mut lapack_complex_double,
ldu: *const lapack_int,
c: *mut lapack_complex_double,
ldc: *const lapack_int,
work: *mut c_double,
info: *mut lapack_int,
);
pub fn sbdsdc_(
uplo: *const c_char,
compq: *const c_char,
n: *const lapack_int,
d: *mut c_float,
e: *mut c_float,
u: *mut c_float,
ldu: *const lapack_int,
vt: *mut c_float,
ldvt: *const lapack_int,
q: *mut c_float,
iq: *mut lapack_int,
work: *mut c_float,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dbdsdc_(
uplo: *const c_char,
compq: *const c_char,
n: *const lapack_int,
d: *mut c_double,
e: *mut c_double,
u: *mut c_double,
ldu: *const lapack_int,
vt: *mut c_double,
ldvt: *const lapack_int,
q: *mut c_double,
iq: *mut lapack_int,
work: *mut c_double,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn sbdsvdx_(
uplo: *const c_char,
jobz: *const c_char,
range: *const c_char,
n: *const lapack_int,
d: *const c_float,
e: *const c_float,
vl: *const c_float,
vu: *const c_float,
il: *const lapack_int,
iu: *const lapack_int,
ns: *mut lapack_int,
s: *mut c_float,
z: *mut c_float,
ldz: *const lapack_int,
work: *mut c_float,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dbdsvdx_(
uplo: *const c_char,
jobz: *const c_char,
range: *const c_char,
n: *const lapack_int,
d: *const c_double,
e: *const c_double,
vl: *const c_double,
vu: *const c_double,
il: *const lapack_int,
iu: *const lapack_int,
ns: *mut lapack_int,
s: *mut c_double,
z: *mut c_double,
ldz: *const lapack_int,
work: *mut c_double,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn ssytrd_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
d: *mut c_float,
e: *mut c_float,
tau: *mut c_float,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dsytrd_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
d: *mut c_double,
e: *mut c_double,
tau: *mut c_double,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn sorgtr_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
tau: *const c_float,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dorgtr_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
tau: *const c_double,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn sormtr_(
side: *const c_char,
uplo: *const c_char,
trans: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
a: *const c_float,
lda: *const lapack_int,
tau: *const c_float,
c: *mut c_float,
ldc: *const lapack_int,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dormtr_(
side: *const c_char,
uplo: *const c_char,
trans: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
a: *const c_double,
lda: *const lapack_int,
tau: *const c_double,
c: *mut c_double,
ldc: *const lapack_int,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn chetrd_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
d: *mut c_float,
e: *mut c_float,
tau: *mut lapack_complex_float,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zhetrd_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
d: *mut c_double,
e: *mut c_double,
tau: *mut lapack_complex_double,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn cungtr_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
tau: *const lapack_complex_float,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zungtr_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
tau: *const lapack_complex_double,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn cunmtr_(
side: *const c_char,
uplo: *const c_char,
trans: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
tau: *const lapack_complex_float,
c: *mut lapack_complex_float,
ldc: *const lapack_int,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zunmtr_(
side: *const c_char,
uplo: *const c_char,
trans: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
tau: *const lapack_complex_double,
c: *mut lapack_complex_double,
ldc: *const lapack_int,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn ssptrd_(
uplo: *const c_char,
n: *const lapack_int,
ap: *mut c_float,
d: *mut c_float,
e: *mut c_float,
tau: *mut c_float,
info: *mut lapack_int,
);
pub fn dsptrd_(
uplo: *const c_char,
n: *const lapack_int,
ap: *mut c_double,
d: *mut c_double,
e: *mut c_double,
tau: *mut c_double,
info: *mut lapack_int,
);
pub fn sopgtr_(
uplo: *const c_char,
n: *const lapack_int,
ap: *const c_float,
tau: *const c_float,
q: *mut c_float,
ldq: *const lapack_int,
work: *mut c_float,
info: *mut lapack_int,
);
pub fn dopgtr_(
uplo: *const c_char,
n: *const lapack_int,
ap: *const c_double,
tau: *const c_double,
q: *mut c_double,
ldq: *const lapack_int,
work: *mut c_double,
info: *mut lapack_int,
);
pub fn sopmtr_(
side: *const c_char,
uplo: *const c_char,
trans: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
ap: *const c_float,
tau: *const c_float,
c: *mut c_float,
ldc: *const lapack_int,
work: *mut c_float,
info: *mut lapack_int,
);
pub fn dopmtr_(
side: *const c_char,
uplo: *const c_char,
trans: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
ap: *const c_double,
tau: *const c_double,
c: *mut c_double,
ldc: *const lapack_int,
work: *mut c_double,
info: *mut lapack_int,
);
pub fn chptrd_(
uplo: *const c_char,
n: *const lapack_int,
ap: *mut lapack_complex_float,
d: *mut c_float,
e: *mut c_float,
tau: *mut lapack_complex_float,
info: *mut lapack_int,
);
pub fn zhptrd_(
uplo: *const c_char,
n: *const lapack_int,
ap: *mut lapack_complex_double,
d: *mut c_double,
e: *mut c_double,
tau: *mut lapack_complex_double,
info: *mut lapack_int,
);
pub fn cupgtr_(
uplo: *const c_char,
n: *const lapack_int,
ap: *const lapack_complex_float,
tau: *const lapack_complex_float,
q: *mut lapack_complex_float,
ldq: *const lapack_int,
work: *mut lapack_complex_float,
info: *mut lapack_int,
);
pub fn zupgtr_(
uplo: *const c_char,
n: *const lapack_int,
ap: *const lapack_complex_double,
tau: *const lapack_complex_double,
q: *mut lapack_complex_double,
ldq: *const lapack_int,
work: *mut lapack_complex_double,
info: *mut lapack_int,
);
pub fn cupmtr_(
side: *const c_char,
uplo: *const c_char,
trans: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
ap: *const lapack_complex_float,
tau: *const lapack_complex_float,
c: *mut lapack_complex_float,
ldc: *const lapack_int,
work: *mut lapack_complex_float,
info: *mut lapack_int,
);
pub fn zupmtr_(
side: *const c_char,
uplo: *const c_char,
trans: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
ap: *const lapack_complex_double,
tau: *const lapack_complex_double,
c: *mut lapack_complex_double,
ldc: *const lapack_int,
work: *mut lapack_complex_double,
info: *mut lapack_int,
);
pub fn ssbtrd_(
vect: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
ab: *mut c_float,
ldab: *const lapack_int,
d: *mut c_float,
e: *mut c_float,
q: *mut c_float,
ldq: *const lapack_int,
work: *mut c_float,
info: *mut lapack_int,
);
pub fn dsbtrd_(
vect: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
ab: *mut c_double,
ldab: *const lapack_int,
d: *mut c_double,
e: *mut c_double,
q: *mut c_double,
ldq: *const lapack_int,
work: *mut c_double,
info: *mut lapack_int,
);
pub fn chbtrd_(
vect: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
ab: *mut lapack_complex_float,
ldab: *const lapack_int,
d: *mut c_float,
e: *mut c_float,
q: *mut lapack_complex_float,
ldq: *const lapack_int,
work: *mut lapack_complex_float,
info: *mut lapack_int,
);
pub fn zhbtrd_(
vect: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
ab: *mut lapack_complex_double,
ldab: *const lapack_int,
d: *mut c_double,
e: *mut c_double,
q: *mut lapack_complex_double,
ldq: *const lapack_int,
work: *mut lapack_complex_double,
info: *mut lapack_int,
);
pub fn ssterf_(n: *const lapack_int, d: *mut c_float, e: *mut c_float, info: *mut lapack_int);
pub fn dsterf_(n: *const lapack_int, d: *mut c_double, e: *mut c_double, info: *mut lapack_int);
pub fn ssteqr_(
compz: *const c_char,
n: *const lapack_int,
d: *mut c_float,
e: *mut c_float,
z: *mut c_float,
ldz: *const lapack_int,
work: *mut c_float,
info: *mut lapack_int,
);
pub fn dsteqr_(
compz: *const c_char,
n: *const lapack_int,
d: *mut c_double,
e: *mut c_double,
z: *mut c_double,
ldz: *const lapack_int,
work: *mut c_double,
info: *mut lapack_int,
);
pub fn csteqr_(
compz: *const c_char,
n: *const lapack_int,
d: *mut c_float,
e: *mut c_float,
z: *mut lapack_complex_float,
ldz: *const lapack_int,
work: *mut c_float,
info: *mut lapack_int,
);
pub fn zsteqr_(
compz: *const c_char,
n: *const lapack_int,
d: *mut c_double,
e: *mut c_double,
z: *mut lapack_complex_double,
ldz: *const lapack_int,
work: *mut c_double,
info: *mut lapack_int,
);
pub fn sstemr_(
jobz: *const c_char,
range: *const c_char,
n: *const lapack_int,
d: *mut c_float,
e: *mut c_float,
vl: *const c_float,
vu: *const c_float,
il: *const lapack_int,
iu: *const lapack_int,
m: *mut lapack_int,
w: *mut c_float,
z: *mut c_float,
ldz: *const lapack_int,
nzc: *const lapack_int,
isuppz: *mut lapack_int,
tryrac: *mut lapack_logical,
work: *mut c_float,
lwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dstemr_(
jobz: *const c_char,
range: *const c_char,
n: *const lapack_int,
d: *mut c_double,
e: *mut c_double,
vl: *const c_double,
vu: *const c_double,
il: *const lapack_int,
iu: *const lapack_int,
m: *mut lapack_int,
w: *mut c_double,
z: *mut c_double,
ldz: *const lapack_int,
nzc: *const lapack_int,
isuppz: *mut lapack_int,
tryrac: *mut lapack_logical,
work: *mut c_double,
lwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn cstemr_(
jobz: *const c_char,
range: *const c_char,
n: *const lapack_int,
d: *mut c_float,
e: *mut c_float,
vl: *const c_float,
vu: *const c_float,
il: *const lapack_int,
iu: *const lapack_int,
m: *mut lapack_int,
w: *mut c_float,
z: *mut lapack_complex_float,
ldz: *const lapack_int,
nzc: *const lapack_int,
isuppz: *mut lapack_int,
tryrac: *mut lapack_logical,
work: *mut c_float,
lwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zstemr_(
jobz: *const c_char,
range: *const c_char,
n: *const lapack_int,
d: *mut c_double,
e: *mut c_double,
vl: *const c_double,
vu: *const c_double,
il: *const lapack_int,
iu: *const lapack_int,
m: *mut lapack_int,
w: *mut c_double,
z: *mut lapack_complex_double,
ldz: *const lapack_int,
nzc: *const lapack_int,
isuppz: *mut lapack_int,
tryrac: *mut lapack_logical,
work: *mut c_double,
lwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn sstedc_(
compz: *const c_char,
n: *const lapack_int,
d: *mut c_float,
e: *mut c_float,
z: *mut c_float,
ldz: *const lapack_int,
work: *mut c_float,
lwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dstedc_(
compz: *const c_char,
n: *const lapack_int,
d: *mut c_double,
e: *mut c_double,
z: *mut c_double,
ldz: *const lapack_int,
work: *mut c_double,
lwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn cstedc_(
compz: *const c_char,
n: *const lapack_int,
d: *mut c_float,
e: *mut c_float,
z: *mut lapack_complex_float,
ldz: *const lapack_int,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
rwork: *mut c_float,
lrwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zstedc_(
compz: *const c_char,
n: *const lapack_int,
d: *mut c_double,
e: *mut c_double,
z: *mut lapack_complex_double,
ldz: *const lapack_int,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
rwork: *mut c_double,
lrwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn sstegr_(
jobz: *const c_char,
range: *const c_char,
n: *const lapack_int,
d: *mut c_float,
e: *mut c_float,
vl: *const c_float,
vu: *const c_float,
il: *const lapack_int,
iu: *const lapack_int,
abstol: *const c_float,
m: *mut lapack_int,
w: *mut c_float,
z: *mut c_float,
ldz: *const lapack_int,
isuppz: *mut lapack_int,
work: *mut c_float,
lwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dstegr_(
jobz: *const c_char,
range: *const c_char,
n: *const lapack_int,
d: *mut c_double,
e: *mut c_double,
vl: *const c_double,
vu: *const c_double,
il: *const lapack_int,
iu: *const lapack_int,
abstol: *const c_double,
m: *mut lapack_int,
w: *mut c_double,
z: *mut c_double,
ldz: *const lapack_int,
isuppz: *mut lapack_int,
work: *mut c_double,
lwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn cstegr_(
jobz: *const c_char,
range: *const c_char,
n: *const lapack_int,
d: *mut c_float,
e: *mut c_float,
vl: *const c_float,
vu: *const c_float,
il: *const lapack_int,
iu: *const lapack_int,
abstol: *const c_float,
m: *mut lapack_int,
w: *mut c_float,
z: *mut lapack_complex_float,
ldz: *const lapack_int,
isuppz: *mut lapack_int,
work: *mut c_float,
lwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zstegr_(
jobz: *const c_char,
range: *const c_char,
n: *const lapack_int,
d: *mut c_double,
e: *mut c_double,
vl: *const c_double,
vu: *const c_double,
il: *const lapack_int,
iu: *const lapack_int,
abstol: *const c_double,
m: *mut lapack_int,
w: *mut c_double,
z: *mut lapack_complex_double,
ldz: *const lapack_int,
isuppz: *mut lapack_int,
work: *mut c_double,
lwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn spteqr_(
compz: *const c_char,
n: *const lapack_int,
d: *mut c_float,
e: *mut c_float,
z: *mut c_float,
ldz: *const lapack_int,
work: *mut c_float,
info: *mut lapack_int,
);
pub fn dpteqr_(
compz: *const c_char,
n: *const lapack_int,
d: *mut c_double,
e: *mut c_double,
z: *mut c_double,
ldz: *const lapack_int,
work: *mut c_double,
info: *mut lapack_int,
);
pub fn cpteqr_(
compz: *const c_char,
n: *const lapack_int,
d: *mut c_float,
e: *mut c_float,
z: *mut lapack_complex_float,
ldz: *const lapack_int,
work: *mut c_float,
info: *mut lapack_int,
);
pub fn zpteqr_(
compz: *const c_char,
n: *const lapack_int,
d: *mut c_double,
e: *mut c_double,
z: *mut lapack_complex_double,
ldz: *const lapack_int,
work: *mut c_double,
info: *mut lapack_int,
);
pub fn sstebz_(
range: *const c_char,
order: *const c_char,
n: *const lapack_int,
vl: *const c_float,
vu: *const c_float,
il: *const lapack_int,
iu: *const lapack_int,
abstol: *const c_float,
d: *const c_float,
e: *const c_float,
m: *mut lapack_int,
nsplit: *mut lapack_int,
w: *mut c_float,
iblock: *mut lapack_int,
isplit: *mut lapack_int,
work: *mut c_float,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dstebz_(
range: *const c_char,
order: *const c_char,
n: *const lapack_int,
vl: *const c_double,
vu: *const c_double,
il: *const lapack_int,
iu: *const lapack_int,
abstol: *const c_double,
d: *const c_double,
e: *const c_double,
m: *mut lapack_int,
nsplit: *mut lapack_int,
w: *mut c_double,
iblock: *mut lapack_int,
isplit: *mut lapack_int,
work: *mut c_double,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn sstein_(
n: *const lapack_int,
d: *const c_float,
e: *const c_float,
m: *const lapack_int,
w: *const c_float,
iblock: *const lapack_int,
isplit: *const lapack_int,
z: *mut c_float,
ldz: *const lapack_int,
work: *mut c_float,
iwork: *mut lapack_int,
ifail: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dstein_(
n: *const lapack_int,
d: *const c_double,
e: *const c_double,
m: *const lapack_int,
w: *const c_double,
iblock: *const lapack_int,
isplit: *const lapack_int,
z: *mut c_double,
ldz: *const lapack_int,
work: *mut c_double,
iwork: *mut lapack_int,
ifail: *mut lapack_int,
info: *mut lapack_int,
);
pub fn cstein_(
n: *const lapack_int,
d: *const c_float,
e: *const c_float,
m: *const lapack_int,
w: *const c_float,
iblock: *const lapack_int,
isplit: *const lapack_int,
z: *mut lapack_complex_float,
ldz: *const lapack_int,
work: *mut c_float,
iwork: *mut lapack_int,
ifail: *mut lapack_int,
info: *mut lapack_int,
);
pub fn zstein_(
n: *const lapack_int,
d: *const c_double,
e: *const c_double,
m: *const lapack_int,
w: *const c_double,
iblock: *const lapack_int,
isplit: *const lapack_int,
z: *mut lapack_complex_double,
ldz: *const lapack_int,
work: *mut c_double,
iwork: *mut lapack_int,
ifail: *mut lapack_int,
info: *mut lapack_int,
);
pub fn sdisna_(
job: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
d: *const c_float,
sep: *mut c_float,
info: *mut lapack_int,
);
pub fn ddisna_(
job: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
d: *const c_double,
sep: *mut c_double,
info: *mut lapack_int,
);
pub fn ssygst_(
itype: *const lapack_int,
uplo: *const c_char,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
b: *const c_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn dsygst_(
itype: *const lapack_int,
uplo: *const c_char,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
b: *const c_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn chegst_(
itype: *const lapack_int,
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
b: *const lapack_complex_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn zhegst_(
itype: *const lapack_int,
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
b: *const lapack_complex_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn sspgst_(
itype: *const lapack_int,
uplo: *const c_char,
n: *const lapack_int,
ap: *mut c_float,
bp: *const c_float,
info: *mut lapack_int,
);
pub fn dspgst_(
itype: *const lapack_int,
uplo: *const c_char,
n: *const lapack_int,
ap: *mut c_double,
bp: *const c_double,
info: *mut lapack_int,
);
pub fn chpgst_(
itype: *const lapack_int,
uplo: *const c_char,
n: *const lapack_int,
ap: *mut lapack_complex_float,
bp: *const lapack_complex_float,
info: *mut lapack_int,
);
pub fn zhpgst_(
itype: *const lapack_int,
uplo: *const c_char,
n: *const lapack_int,
ap: *mut lapack_complex_double,
bp: *const lapack_complex_double,
info: *mut lapack_int,
);
pub fn ssbgst_(
vect: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
ka: *const lapack_int,
kb: *const lapack_int,
ab: *mut c_float,
ldab: *const lapack_int,
bb: *const c_float,
ldbb: *const lapack_int,
x: *mut c_float,
ldx: *const lapack_int,
work: *mut c_float,
info: *mut lapack_int,
);
pub fn dsbgst_(
vect: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
ka: *const lapack_int,
kb: *const lapack_int,
ab: *mut c_double,
ldab: *const lapack_int,
bb: *const c_double,
ldbb: *const lapack_int,
x: *mut c_double,
ldx: *const lapack_int,
work: *mut c_double,
info: *mut lapack_int,
);
pub fn chbgst_(
vect: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
ka: *const lapack_int,
kb: *const lapack_int,
ab: *mut lapack_complex_float,
ldab: *const lapack_int,
bb: *const lapack_complex_float,
ldbb: *const lapack_int,
x: *mut lapack_complex_float,
ldx: *const lapack_int,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn zhbgst_(
vect: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
ka: *const lapack_int,
kb: *const lapack_int,
ab: *mut lapack_complex_double,
ldab: *const lapack_int,
bb: *const lapack_complex_double,
ldbb: *const lapack_int,
x: *mut lapack_complex_double,
ldx: *const lapack_int,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn spbstf_(
uplo: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
ab: *mut c_float,
ldab: *const lapack_int,
info: *mut lapack_int,
);
pub fn dpbstf_(
uplo: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
ab: *mut c_double,
ldab: *const lapack_int,
info: *mut lapack_int,
);
pub fn cpbstf_(
uplo: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
ab: *mut lapack_complex_float,
ldab: *const lapack_int,
info: *mut lapack_int,
);
pub fn zpbstf_(
uplo: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
ab: *mut lapack_complex_double,
ldab: *const lapack_int,
info: *mut lapack_int,
);
pub fn sgehrd_(
n: *const lapack_int,
ilo: *const lapack_int,
ihi: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
tau: *mut c_float,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dgehrd_(
n: *const lapack_int,
ilo: *const lapack_int,
ihi: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
tau: *mut c_double,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn cgehrd_(
n: *const lapack_int,
ilo: *const lapack_int,
ihi: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
tau: *mut lapack_complex_float,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zgehrd_(
n: *const lapack_int,
ilo: *const lapack_int,
ihi: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
tau: *mut lapack_complex_double,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn sorghr_(
n: *const lapack_int,
ilo: *const lapack_int,
ihi: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
tau: *const c_float,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dorghr_(
n: *const lapack_int,
ilo: *const lapack_int,
ihi: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
tau: *const c_double,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn sormhr_(
side: *const c_char,
trans: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
ilo: *const lapack_int,
ihi: *const lapack_int,
a: *const c_float,
lda: *const lapack_int,
tau: *const c_float,
c: *mut c_float,
ldc: *const lapack_int,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dormhr_(
side: *const c_char,
trans: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
ilo: *const lapack_int,
ihi: *const lapack_int,
a: *const c_double,
lda: *const lapack_int,
tau: *const c_double,
c: *mut c_double,
ldc: *const lapack_int,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn cunghr_(
n: *const lapack_int,
ilo: *const lapack_int,
ihi: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
tau: *const lapack_complex_float,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zunghr_(
n: *const lapack_int,
ilo: *const lapack_int,
ihi: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
tau: *const lapack_complex_double,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn cunmhr_(
side: *const c_char,
trans: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
ilo: *const lapack_int,
ihi: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
tau: *const lapack_complex_float,
c: *mut lapack_complex_float,
ldc: *const lapack_int,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zunmhr_(
side: *const c_char,
trans: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
ilo: *const lapack_int,
ihi: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
tau: *const lapack_complex_double,
c: *mut lapack_complex_double,
ldc: *const lapack_int,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn sgebal_(
job: *const c_char,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
ilo: *mut lapack_int,
ihi: *mut lapack_int,
scale: *mut c_float,
info: *mut lapack_int,
);
pub fn dgebal_(
job: *const c_char,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
ilo: *mut lapack_int,
ihi: *mut lapack_int,
scale: *mut c_double,
info: *mut lapack_int,
);
pub fn cgebal_(
job: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
ilo: *mut lapack_int,
ihi: *mut lapack_int,
scale: *mut c_float,
info: *mut lapack_int,
);
pub fn zgebal_(
job: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
ilo: *mut lapack_int,
ihi: *mut lapack_int,
scale: *mut c_double,
info: *mut lapack_int,
);
pub fn sgebak_(
job: *const c_char,
side: *const c_char,
n: *const lapack_int,
ilo: *const lapack_int,
ihi: *const lapack_int,
scale: *const c_float,
m: *const lapack_int,
v: *mut c_float,
ldv: *const lapack_int,
info: *mut lapack_int,
);
pub fn dgebak_(
job: *const c_char,
side: *const c_char,
n: *const lapack_int,
ilo: *const lapack_int,
ihi: *const lapack_int,
scale: *const c_double,
m: *const lapack_int,
v: *mut c_double,
ldv: *const lapack_int,
info: *mut lapack_int,
);
pub fn cgebak_(
job: *const c_char,
side: *const c_char,
n: *const lapack_int,
ilo: *const lapack_int,
ihi: *const lapack_int,
scale: *const c_float,
m: *const lapack_int,
v: *mut lapack_complex_float,
ldv: *const lapack_int,
info: *mut lapack_int,
);
pub fn zgebak_(
job: *const c_char,
side: *const c_char,
n: *const lapack_int,
ilo: *const lapack_int,
ihi: *const lapack_int,
scale: *const c_double,
m: *const lapack_int,
v: *mut lapack_complex_double,
ldv: *const lapack_int,
info: *mut lapack_int,
);
pub fn shseqr_(
job: *const c_char,
compz: *const c_char,
n: *const lapack_int,
ilo: *const lapack_int,
ihi: *const lapack_int,
h: *mut c_float,
ldh: *const lapack_int,
wr: *mut c_float,
wi: *mut c_float,
z: *mut c_float,
ldz: *const lapack_int,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dhseqr_(
job: *const c_char,
compz: *const c_char,
n: *const lapack_int,
ilo: *const lapack_int,
ihi: *const lapack_int,
h: *mut c_double,
ldh: *const lapack_int,
wr: *mut c_double,
wi: *mut c_double,
z: *mut c_double,
ldz: *const lapack_int,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn chseqr_(
job: *const c_char,
compz: *const c_char,
n: *const lapack_int,
ilo: *const lapack_int,
ihi: *const lapack_int,
h: *mut lapack_complex_float,
ldh: *const lapack_int,
w: *mut lapack_complex_float,
z: *mut lapack_complex_float,
ldz: *const lapack_int,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zhseqr_(
job: *const c_char,
compz: *const c_char,
n: *const lapack_int,
ilo: *const lapack_int,
ihi: *const lapack_int,
h: *mut lapack_complex_double,
ldh: *const lapack_int,
w: *mut lapack_complex_double,
z: *mut lapack_complex_double,
ldz: *const lapack_int,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn shsein_(
job: *const c_char,
eigsrc: *const c_char,
initv: *const c_char,
select: *mut lapack_logical,
n: *const lapack_int,
h: *const c_float,
ldh: *const lapack_int,
wr: *mut c_float,
wi: *const c_float,
vl: *mut c_float,
ldvl: *const lapack_int,
vr: *mut c_float,
ldvr: *const lapack_int,
mm: *const lapack_int,
m: *mut lapack_int,
work: *mut c_float,
ifaill: *mut lapack_int,
ifailr: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dhsein_(
job: *const c_char,
eigsrc: *const c_char,
initv: *const c_char,
select: *mut lapack_logical,
n: *const lapack_int,
h: *const c_double,
ldh: *const lapack_int,
wr: *mut c_double,
wi: *const c_double,
vl: *mut c_double,
ldvl: *const lapack_int,
vr: *mut c_double,
ldvr: *const lapack_int,
mm: *const lapack_int,
m: *mut lapack_int,
work: *mut c_double,
ifaill: *mut lapack_int,
ifailr: *mut lapack_int,
info: *mut lapack_int,
);
pub fn chsein_(
job: *const c_char,
eigsrc: *const c_char,
initv: *const c_char,
select: *const lapack_logical,
n: *const lapack_int,
h: *const lapack_complex_float,
ldh: *const lapack_int,
w: *mut lapack_complex_float,
vl: *mut lapack_complex_float,
ldvl: *const lapack_int,
vr: *mut lapack_complex_float,
ldvr: *const lapack_int,
mm: *const lapack_int,
m: *mut lapack_int,
work: *mut lapack_complex_float,
rwork: *mut c_float,
ifaill: *mut lapack_int,
ifailr: *mut lapack_int,
info: *mut lapack_int,
);
pub fn zhsein_(
job: *const c_char,
eigsrc: *const c_char,
initv: *const c_char,
select: *const lapack_logical,
n: *const lapack_int,
h: *const lapack_complex_double,
ldh: *const lapack_int,
w: *mut lapack_complex_double,
vl: *mut lapack_complex_double,
ldvl: *const lapack_int,
vr: *mut lapack_complex_double,
ldvr: *const lapack_int,
mm: *const lapack_int,
m: *mut lapack_int,
work: *mut lapack_complex_double,
rwork: *mut c_double,
ifaill: *mut lapack_int,
ifailr: *mut lapack_int,
info: *mut lapack_int,
);
pub fn strevc_(
side: *const c_char,
howmny: *const c_char,
select: *mut lapack_logical,
n: *const lapack_int,
t: *const c_float,
ldt: *const lapack_int,
vl: *mut c_float,
ldvl: *const lapack_int,
vr: *mut c_float,
ldvr: *const lapack_int,
mm: *const lapack_int,
m: *mut lapack_int,
work: *mut c_float,
info: *mut lapack_int,
);
pub fn dtrevc_(
side: *const c_char,
howmny: *const c_char,
select: *mut lapack_logical,
n: *const lapack_int,
t: *const c_double,
ldt: *const lapack_int,
vl: *mut c_double,
ldvl: *const lapack_int,
vr: *mut c_double,
ldvr: *const lapack_int,
mm: *const lapack_int,
m: *mut lapack_int,
work: *mut c_double,
info: *mut lapack_int,
);
pub fn ctrevc_(
side: *const c_char,
howmny: *const c_char,
select: *const lapack_logical,
n: *const lapack_int,
t: *mut lapack_complex_float,
ldt: *const lapack_int,
vl: *mut lapack_complex_float,
ldvl: *const lapack_int,
vr: *mut lapack_complex_float,
ldvr: *const lapack_int,
mm: *const lapack_int,
m: *mut lapack_int,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn ztrevc_(
side: *const c_char,
howmny: *const c_char,
select: *const lapack_logical,
n: *const lapack_int,
t: *mut lapack_complex_double,
ldt: *const lapack_int,
vl: *mut lapack_complex_double,
ldvl: *const lapack_int,
vr: *mut lapack_complex_double,
ldvr: *const lapack_int,
mm: *const lapack_int,
m: *mut lapack_int,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn strsna_(
job: *const c_char,
howmny: *const c_char,
select: *const lapack_logical,
n: *const lapack_int,
t: *const c_float,
ldt: *const lapack_int,
vl: *const c_float,
ldvl: *const lapack_int,
vr: *const c_float,
ldvr: *const lapack_int,
s: *mut c_float,
sep: *mut c_float,
mm: *const lapack_int,
m: *mut lapack_int,
work: *mut c_float,
ldwork: *const lapack_int,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dtrsna_(
job: *const c_char,
howmny: *const c_char,
select: *const lapack_logical,
n: *const lapack_int,
t: *const c_double,
ldt: *const lapack_int,
vl: *const c_double,
ldvl: *const lapack_int,
vr: *const c_double,
ldvr: *const lapack_int,
s: *mut c_double,
sep: *mut c_double,
mm: *const lapack_int,
m: *mut lapack_int,
work: *mut c_double,
ldwork: *const lapack_int,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn ctrsna_(
job: *const c_char,
howmny: *const c_char,
select: *const lapack_logical,
n: *const lapack_int,
t: *const lapack_complex_float,
ldt: *const lapack_int,
vl: *const lapack_complex_float,
ldvl: *const lapack_int,
vr: *const lapack_complex_float,
ldvr: *const lapack_int,
s: *mut c_float,
sep: *mut c_float,
mm: *const lapack_int,
m: *mut lapack_int,
work: *mut lapack_complex_float,
ldwork: *const lapack_int,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn ztrsna_(
job: *const c_char,
howmny: *const c_char,
select: *const lapack_logical,
n: *const lapack_int,
t: *const lapack_complex_double,
ldt: *const lapack_int,
vl: *const lapack_complex_double,
ldvl: *const lapack_int,
vr: *const lapack_complex_double,
ldvr: *const lapack_int,
s: *mut c_double,
sep: *mut c_double,
mm: *const lapack_int,
m: *mut lapack_int,
work: *mut lapack_complex_double,
ldwork: *const lapack_int,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn strexc_(
compq: *const c_char,
n: *const lapack_int,
t: *mut c_float,
ldt: *const lapack_int,
q: *mut c_float,
ldq: *const lapack_int,
ifst: *const lapack_int,
ilst: *mut lapack_int,
work: *mut c_float,
info: *mut lapack_int,
);
pub fn dtrexc_(
compq: *const c_char,
n: *const lapack_int,
t: *mut c_double,
ldt: *const lapack_int,
q: *mut c_double,
ldq: *const lapack_int,
ifst: *const lapack_int,
ilst: *mut lapack_int,
work: *mut c_double,
info: *mut lapack_int,
);
pub fn ctrexc_(
compq: *const c_char,
n: *const lapack_int,
t: *mut lapack_complex_float,
ldt: *const lapack_int,
q: *mut lapack_complex_float,
ldq: *const lapack_int,
ifst: *const lapack_int,
ilst: *const lapack_int,
info: *const lapack_int,
);
pub fn ztrexc_(
compq: *const c_char,
n: *const lapack_int,
t: *mut lapack_complex_double,
ldt: *const lapack_int,
q: *mut lapack_complex_double,
ldq: *const lapack_int,
ifst: *const lapack_int,
ilst: *const lapack_int,
info: *const lapack_int,
);
pub fn strsen_(
job: *const c_char,
compq: *const c_char,
select: *const lapack_logical,
n: *const lapack_int,
t: *mut c_float,
ldt: *const lapack_int,
q: *mut c_float,
ldq: *const lapack_int,
wr: *mut c_float,
wi: *mut c_float,
m: *mut lapack_int,
s: *mut c_float,
sep: *mut c_float,
work: *mut c_float,
lwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dtrsen_(
job: *const c_char,
compq: *const c_char,
select: *const lapack_logical,
n: *const lapack_int,
t: *mut c_double,
ldt: *const lapack_int,
q: *mut c_double,
ldq: *const lapack_int,
wr: *mut c_double,
wi: *mut c_double,
m: *mut lapack_int,
s: *mut c_double,
sep: *mut c_double,
work: *mut c_double,
lwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn ctrsen_(
job: *const c_char,
compq: *const c_char,
select: *const lapack_logical,
n: *const lapack_int,
t: *mut lapack_complex_float,
ldt: *const lapack_int,
q: *mut lapack_complex_float,
ldq: *const lapack_int,
w: *mut lapack_complex_float,
m: *mut lapack_int,
s: *mut c_float,
sep: *mut c_float,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn ztrsen_(
job: *const c_char,
compq: *const c_char,
select: *const lapack_logical,
n: *const lapack_int,
t: *mut lapack_complex_double,
ldt: *const lapack_int,
q: *mut lapack_complex_double,
ldq: *const lapack_int,
w: *mut lapack_complex_double,
m: *mut lapack_int,
s: *mut c_double,
sep: *mut c_double,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn strsyl_(
trana: *const c_char,
tranb: *const c_char,
isgn: *const lapack_int,
m: *const lapack_int,
n: *const lapack_int,
a: *const c_float,
lda: *const lapack_int,
b: *const c_float,
ldb: *const lapack_int,
c: *mut c_float,
ldc: *const lapack_int,
scale: *mut c_float,
info: *mut lapack_int,
);
pub fn dtrsyl_(
trana: *const c_char,
tranb: *const c_char,
isgn: *const lapack_int,
m: *const lapack_int,
n: *const lapack_int,
a: *const c_double,
lda: *const lapack_int,
b: *const c_double,
ldb: *const lapack_int,
c: *mut c_double,
ldc: *const lapack_int,
scale: *mut c_double,
info: *mut lapack_int,
);
pub fn ctrsyl_(
trana: *const c_char,
tranb: *const c_char,
isgn: *const lapack_int,
m: *const lapack_int,
n: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
b: *const lapack_complex_float,
ldb: *const lapack_int,
c: *mut lapack_complex_float,
ldc: *const lapack_int,
scale: *mut c_float,
info: *mut lapack_int,
);
pub fn ztrsyl_(
trana: *const c_char,
tranb: *const c_char,
isgn: *const lapack_int,
m: *const lapack_int,
n: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
b: *const lapack_complex_double,
ldb: *const lapack_int,
c: *mut lapack_complex_double,
ldc: *const lapack_int,
scale: *mut c_double,
info: *mut lapack_int,
);
pub fn sgghrd_(
compq: *const c_char,
compz: *const c_char,
n: *const lapack_int,
ilo: *const lapack_int,
ihi: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
b: *mut c_float,
ldb: *const lapack_int,
q: *mut c_float,
ldq: *const lapack_int,
z: *mut c_float,
ldz: *const lapack_int,
info: *mut lapack_int,
);
pub fn dgghrd_(
compq: *const c_char,
compz: *const c_char,
n: *const lapack_int,
ilo: *const lapack_int,
ihi: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
b: *mut c_double,
ldb: *const lapack_int,
q: *mut c_double,
ldq: *const lapack_int,
z: *mut c_double,
ldz: *const lapack_int,
info: *mut lapack_int,
);
pub fn cgghrd_(
compq: *const c_char,
compz: *const c_char,
n: *const lapack_int,
ilo: *const lapack_int,
ihi: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
q: *mut lapack_complex_float,
ldq: *const lapack_int,
z: *mut lapack_complex_float,
ldz: *const lapack_int,
info: *mut lapack_int,
);
pub fn zgghrd_(
compq: *const c_char,
compz: *const c_char,
n: *const lapack_int,
ilo: *const lapack_int,
ihi: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
q: *mut lapack_complex_double,
ldq: *const lapack_int,
z: *mut lapack_complex_double,
ldz: *const lapack_int,
info: *mut lapack_int,
);
pub fn sgghd3_(
compq: *const c_char,
compz: *const c_char,
n: *const lapack_int,
ilo: *const lapack_int,
ihi: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
b: *mut c_float,
ldb: *const lapack_int,
q: *mut c_float,
ldq: *const lapack_int,
z: *mut c_float,
ldz: *const lapack_int,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dgghd3_(
compq: *const c_char,
compz: *const c_char,
n: *const lapack_int,
ilo: *const lapack_int,
ihi: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
b: *mut c_double,
ldb: *const lapack_int,
q: *mut c_double,
ldq: *const lapack_int,
z: *mut c_double,
ldz: *const lapack_int,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn cgghd3_(
compq: *const c_char,
compz: *const c_char,
n: *const lapack_int,
ilo: *const lapack_int,
ihi: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
q: *mut lapack_complex_float,
ldq: *const lapack_int,
z: *mut lapack_complex_float,
ldz: *const lapack_int,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zgghd3_(
compq: *const c_char,
compz: *const c_char,
n: *const lapack_int,
ilo: *const lapack_int,
ihi: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
q: *mut lapack_complex_double,
ldq: *const lapack_int,
z: *mut lapack_complex_double,
ldz: *const lapack_int,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn sggbal_(
job: *const c_char,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
b: *mut c_float,
ldb: *const lapack_int,
ilo: *mut lapack_int,
ihi: *mut lapack_int,
lscale: *mut c_float,
rscale: *mut c_float,
work: *mut c_float,
info: *mut lapack_int,
);
pub fn dggbal_(
job: *const c_char,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
b: *mut c_double,
ldb: *const lapack_int,
ilo: *mut lapack_int,
ihi: *mut lapack_int,
lscale: *mut c_double,
rscale: *mut c_double,
work: *mut c_double,
info: *mut lapack_int,
);
pub fn cggbal_(
job: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
ilo: *mut lapack_int,
ihi: *mut lapack_int,
lscale: *mut c_float,
rscale: *mut c_float,
work: *mut c_float,
info: *mut lapack_int,
);
pub fn zggbal_(
job: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
ilo: *mut lapack_int,
ihi: *mut lapack_int,
lscale: *mut c_double,
rscale: *mut c_double,
work: *mut c_double,
info: *mut lapack_int,
);
pub fn sggbak_(
job: *const c_char,
side: *const c_char,
n: *const lapack_int,
ilo: *const lapack_int,
ihi: *const lapack_int,
lscale: *const c_float,
rscale: *const c_float,
m: *const lapack_int,
v: *mut c_float,
ldv: *const lapack_int,
info: *mut lapack_int,
);
pub fn dggbak_(
job: *const c_char,
side: *const c_char,
n: *const lapack_int,
ilo: *const lapack_int,
ihi: *const lapack_int,
lscale: *const c_double,
rscale: *const c_double,
m: *const lapack_int,
v: *mut c_double,
ldv: *const lapack_int,
info: *mut lapack_int,
);
pub fn cggbak_(
job: *const c_char,
side: *const c_char,
n: *const lapack_int,
ilo: *const lapack_int,
ihi: *const lapack_int,
lscale: *const c_float,
rscale: *const c_float,
m: *const lapack_int,
v: *mut lapack_complex_float,
ldv: *const lapack_int,
info: *mut lapack_int,
);
pub fn zggbak_(
job: *const c_char,
side: *const c_char,
n: *const lapack_int,
ilo: *const lapack_int,
ihi: *const lapack_int,
lscale: *const c_double,
rscale: *const c_double,
m: *const lapack_int,
v: *mut lapack_complex_double,
ldv: *const lapack_int,
info: *mut lapack_int,
);
pub fn shgeqz_(
job: *const c_char,
compq: *const c_char,
compz: *const c_char,
n: *const lapack_int,
ilo: *const lapack_int,
ihi: *const lapack_int,
h: *mut c_float,
ldh: *const lapack_int,
t: *mut c_float,
ldt: *const lapack_int,
alphar: *mut c_float,
alphai: *mut c_float,
beta: *mut c_float,
q: *mut c_float,
ldq: *const lapack_int,
z: *mut c_float,
ldz: *const lapack_int,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dhgeqz_(
job: *const c_char,
compq: *const c_char,
compz: *const c_char,
n: *const lapack_int,
ilo: *const lapack_int,
ihi: *const lapack_int,
h: *mut c_double,
ldh: *const lapack_int,
t: *mut c_double,
ldt: *const lapack_int,
alphar: *mut c_double,
alphai: *mut c_double,
beta: *mut c_double,
q: *mut c_double,
ldq: *const lapack_int,
z: *mut c_double,
ldz: *const lapack_int,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn chgeqz_(
job: *const c_char,
compq: *const c_char,
compz: *const c_char,
n: *const lapack_int,
ilo: *const lapack_int,
ihi: *const lapack_int,
h: *mut lapack_complex_float,
ldh: *const lapack_int,
t: *mut lapack_complex_float,
ldt: *const lapack_int,
alpha: *mut lapack_complex_float,
beta: *mut lapack_complex_float,
q: *mut lapack_complex_float,
ldq: *const lapack_int,
z: *mut lapack_complex_float,
ldz: *const lapack_int,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn zhgeqz_(
job: *const c_char,
compq: *const c_char,
compz: *const c_char,
n: *const lapack_int,
ilo: *const lapack_int,
ihi: *const lapack_int,
h: *mut lapack_complex_double,
ldh: *const lapack_int,
t: *mut lapack_complex_double,
ldt: *const lapack_int,
alpha: *mut lapack_complex_double,
beta: *mut lapack_complex_double,
q: *mut lapack_complex_double,
ldq: *const lapack_int,
z: *mut lapack_complex_double,
ldz: *const lapack_int,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn stgevc_(
side: *const c_char,
howmny: *const c_char,
select: *const lapack_logical,
n: *const lapack_int,
s: *const c_float,
lds: *const lapack_int,
p: *const c_float,
ldp: *const lapack_int,
vl: *mut c_float,
ldvl: *const lapack_int,
vr: *mut c_float,
ldvr: *const lapack_int,
mm: *const lapack_int,
m: *mut lapack_int,
work: *mut c_float,
info: *mut lapack_int,
);
pub fn dtgevc_(
side: *const c_char,
howmny: *const c_char,
select: *const lapack_logical,
n: *const lapack_int,
s: *const c_double,
lds: *const lapack_int,
p: *const c_double,
ldp: *const lapack_int,
vl: *mut c_double,
ldvl: *const lapack_int,
vr: *mut c_double,
ldvr: *const lapack_int,
mm: *const lapack_int,
m: *mut lapack_int,
work: *mut c_double,
info: *mut lapack_int,
);
pub fn ctgevc_(
side: *const c_char,
howmny: *const c_char,
select: *const lapack_logical,
n: *const lapack_int,
s: *const lapack_complex_float,
lds: *const lapack_int,
p: *const lapack_complex_float,
ldp: *const lapack_int,
vl: *mut lapack_complex_float,
ldvl: *const lapack_int,
vr: *mut lapack_complex_float,
ldvr: *const lapack_int,
mm: *const lapack_int,
m: *mut lapack_int,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn ztgevc_(
side: *const c_char,
howmny: *const c_char,
select: *const lapack_logical,
n: *const lapack_int,
s: *const lapack_complex_double,
lds: *const lapack_int,
p: *const lapack_complex_double,
ldp: *const lapack_int,
vl: *mut lapack_complex_double,
ldvl: *const lapack_int,
vr: *mut lapack_complex_double,
ldvr: *const lapack_int,
mm: *const lapack_int,
m: *mut lapack_int,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn stgexc_(
wantq: *const lapack_logical,
wantz: *const lapack_logical,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
b: *mut c_float,
ldb: *const lapack_int,
q: *mut c_float,
ldq: *const lapack_int,
z: *mut c_float,
ldz: *const lapack_int,
ifst: *mut lapack_int,
ilst: *mut lapack_int,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dtgexc_(
wantq: *const lapack_logical,
wantz: *const lapack_logical,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
b: *mut c_double,
ldb: *const lapack_int,
q: *mut c_double,
ldq: *const lapack_int,
z: *mut c_double,
ldz: *const lapack_int,
ifst: *mut lapack_int,
ilst: *mut lapack_int,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn ctgexc_(
wantq: *const lapack_logical,
wantz: *const lapack_logical,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
q: *mut lapack_complex_float,
ldq: *const lapack_int,
z: *mut lapack_complex_float,
ldz: *const lapack_int,
ifst: *const lapack_int,
ilst: *mut lapack_int,
info: *mut lapack_int,
);
pub fn ztgexc_(
wantq: *const lapack_logical,
wantz: *const lapack_logical,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
q: *mut lapack_complex_double,
ldq: *const lapack_int,
z: *mut lapack_complex_double,
ldz: *const lapack_int,
ifst: *const lapack_int,
ilst: *mut lapack_int,
info: *mut lapack_int,
);
pub fn stgsen_(
ijob: *const lapack_int,
wantq: *const lapack_logical,
wantz: *const lapack_logical,
select: *const lapack_logical,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
b: *mut c_float,
ldb: *const lapack_int,
alphar: *mut c_float,
alphai: *mut c_float,
beta: *mut c_float,
q: *mut c_float,
ldq: *const lapack_int,
z: *mut c_float,
ldz: *const lapack_int,
m: *mut lapack_int,
pl: *mut c_float,
pr: *mut c_float,
dif: *mut c_float,
work: *mut c_float,
lwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dtgsen_(
ijob: *const lapack_int,
wantq: *const lapack_logical,
wantz: *const lapack_logical,
select: *const lapack_logical,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
b: *mut c_double,
ldb: *const lapack_int,
alphar: *mut c_double,
alphai: *mut c_double,
beta: *mut c_double,
q: *mut c_double,
ldq: *const lapack_int,
z: *mut c_double,
ldz: *const lapack_int,
m: *mut lapack_int,
pl: *mut c_double,
pr: *mut c_double,
dif: *mut c_double,
work: *mut c_double,
lwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn ctgsen_(
ijob: *const lapack_int,
wantq: *const lapack_logical,
wantz: *const lapack_logical,
select: *const lapack_logical,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
alpha: *mut lapack_complex_float,
beta: *mut lapack_complex_float,
q: *mut lapack_complex_float,
ldq: *const lapack_int,
z: *mut lapack_complex_float,
ldz: *const lapack_int,
m: *mut lapack_int,
pl: *mut c_float,
pr: *mut c_float,
dif: *mut c_float,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn ztgsen_(
ijob: *const lapack_int,
wantq: *const lapack_logical,
wantz: *const lapack_logical,
select: *const lapack_logical,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
alpha: *mut lapack_complex_double,
beta: *mut lapack_complex_double,
q: *mut lapack_complex_double,
ldq: *const lapack_int,
z: *mut lapack_complex_double,
ldz: *const lapack_int,
m: *mut lapack_int,
pl: *mut c_double,
pr: *mut c_double,
dif: *mut c_double,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn stgsyl_(
trans: *const c_char,
ijob: *const lapack_int,
m: *const lapack_int,
n: *const lapack_int,
a: *const c_float,
lda: *const lapack_int,
b: *const c_float,
ldb: *const lapack_int,
c: *mut c_float,
ldc: *const lapack_int,
d: *const c_float,
ldd: *const lapack_int,
e: *const c_float,
lde: *const lapack_int,
f: *mut c_float,
ldf: *const lapack_int,
scale: *mut c_float,
dif: *mut c_float,
work: *mut c_float,
lwork: *const lapack_int,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dtgsyl_(
trans: *const c_char,
ijob: *const lapack_int,
m: *const lapack_int,
n: *const lapack_int,
a: *const c_double,
lda: *const lapack_int,
b: *const c_double,
ldb: *const lapack_int,
c: *mut c_double,
ldc: *const lapack_int,
d: *const c_double,
ldd: *const lapack_int,
e: *const c_double,
lde: *const lapack_int,
f: *mut c_double,
ldf: *const lapack_int,
scale: *mut c_double,
dif: *mut c_double,
work: *mut c_double,
lwork: *const lapack_int,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn ctgsyl_(
trans: *const c_char,
ijob: *const lapack_int,
m: *const lapack_int,
n: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
b: *const lapack_complex_float,
ldb: *const lapack_int,
c: *mut lapack_complex_float,
ldc: *const lapack_int,
d: *const lapack_complex_float,
ldd: *const lapack_int,
e: *const lapack_complex_float,
lde: *const lapack_int,
f: *mut lapack_complex_float,
ldf: *const lapack_int,
scale: *mut c_float,
dif: *mut c_float,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn ztgsyl_(
trans: *const c_char,
ijob: *const lapack_int,
m: *const lapack_int,
n: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
b: *const lapack_complex_double,
ldb: *const lapack_int,
c: *mut lapack_complex_double,
ldc: *const lapack_int,
d: *const lapack_complex_double,
ldd: *const lapack_int,
e: *const lapack_complex_double,
lde: *const lapack_int,
f: *mut lapack_complex_double,
ldf: *const lapack_int,
scale: *mut c_double,
dif: *mut c_double,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn stgsna_(
job: *const c_char,
howmny: *const c_char,
select: *const lapack_logical,
n: *const lapack_int,
a: *const c_float,
lda: *const lapack_int,
b: *const c_float,
ldb: *const lapack_int,
vl: *const c_float,
ldvl: *const lapack_int,
vr: *const c_float,
ldvr: *const lapack_int,
s: *mut c_float,
dif: *mut c_float,
mm: *const lapack_int,
m: *mut lapack_int,
work: *mut c_float,
lwork: *const lapack_int,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dtgsna_(
job: *const c_char,
howmny: *const c_char,
select: *const lapack_logical,
n: *const lapack_int,
a: *const c_double,
lda: *const lapack_int,
b: *const c_double,
ldb: *const lapack_int,
vl: *const c_double,
ldvl: *const lapack_int,
vr: *const c_double,
ldvr: *const lapack_int,
s: *mut c_double,
dif: *mut c_double,
mm: *const lapack_int,
m: *mut lapack_int,
work: *mut c_double,
lwork: *const lapack_int,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn ctgsna_(
job: *const c_char,
howmny: *const c_char,
select: *const lapack_logical,
n: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
b: *const lapack_complex_float,
ldb: *const lapack_int,
vl: *const lapack_complex_float,
ldvl: *const lapack_int,
vr: *const lapack_complex_float,
ldvr: *const lapack_int,
s: *mut c_float,
dif: *mut c_float,
mm: *const lapack_int,
m: *mut lapack_int,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn ztgsna_(
job: *const c_char,
howmny: *const c_char,
select: *const lapack_logical,
n: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
b: *const lapack_complex_double,
ldb: *const lapack_int,
vl: *const lapack_complex_double,
ldvl: *const lapack_int,
vr: *const lapack_complex_double,
ldvr: *const lapack_int,
s: *mut c_double,
dif: *mut c_double,
mm: *const lapack_int,
m: *mut lapack_int,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn sggsvp_(
jobu: *const c_char,
jobv: *const c_char,
jobq: *const c_char,
m: *const lapack_int,
p: *const lapack_int,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
b: *mut c_float,
ldb: *const lapack_int,
tola: *const c_float,
tolb: *const c_float,
k: *mut lapack_int,
l: *mut lapack_int,
u: *mut c_float,
ldu: *const lapack_int,
v: *mut c_float,
ldv: *const lapack_int,
q: *mut c_float,
ldq: *const lapack_int,
iwork: *mut lapack_int,
tau: *mut c_float,
work: *mut c_float,
info: *mut lapack_int,
);
pub fn dggsvp_(
jobu: *const c_char,
jobv: *const c_char,
jobq: *const c_char,
m: *const lapack_int,
p: *const lapack_int,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
b: *mut c_double,
ldb: *const lapack_int,
tola: *const c_double,
tolb: *const c_double,
k: *mut lapack_int,
l: *mut lapack_int,
u: *mut c_double,
ldu: *const lapack_int,
v: *mut c_double,
ldv: *const lapack_int,
q: *mut c_double,
ldq: *const lapack_int,
iwork: *mut lapack_int,
tau: *mut c_double,
work: *mut c_double,
info: *mut lapack_int,
);
pub fn cggsvp_(
jobu: *const c_char,
jobv: *const c_char,
jobq: *const c_char,
m: *const lapack_int,
p: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
tola: *const c_float,
tolb: *const c_float,
k: *mut lapack_int,
l: *mut lapack_int,
u: *mut lapack_complex_float,
ldu: *const lapack_int,
v: *mut lapack_complex_float,
ldv: *const lapack_int,
q: *mut lapack_complex_float,
ldq: *const lapack_int,
iwork: *mut lapack_int,
rwork: *mut c_float,
tau: *mut lapack_complex_float,
work: *mut lapack_complex_float,
info: *mut lapack_int,
);
pub fn zggsvp_(
jobu: *const c_char,
jobv: *const c_char,
jobq: *const c_char,
m: *const lapack_int,
p: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
tola: *const c_double,
tolb: *const c_double,
k: *mut lapack_int,
l: *mut lapack_int,
u: *mut lapack_complex_double,
ldu: *const lapack_int,
v: *mut lapack_complex_double,
ldv: *const lapack_int,
q: *mut lapack_complex_double,
ldq: *const lapack_int,
iwork: *mut lapack_int,
rwork: *mut c_double,
tau: *mut lapack_complex_double,
work: *mut lapack_complex_double,
info: *mut lapack_int,
);
pub fn sggsvp3_(
jobu: *const c_char,
jobv: *const c_char,
jobq: *const c_char,
m: *const lapack_int,
p: *const lapack_int,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
b: *mut c_float,
ldb: *const lapack_int,
tola: *const c_float,
tolb: *const c_float,
k: *mut lapack_int,
l: *mut lapack_int,
u: *mut c_float,
ldu: *const lapack_int,
v: *mut c_float,
ldv: *const lapack_int,
q: *mut c_float,
ldq: *const lapack_int,
iwork: *mut lapack_int,
tau: *mut c_float,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dggsvp3_(
jobu: *const c_char,
jobv: *const c_char,
jobq: *const c_char,
m: *const lapack_int,
p: *const lapack_int,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
b: *mut c_double,
ldb: *const lapack_int,
tola: *const c_double,
tolb: *const c_double,
k: *mut lapack_int,
l: *mut lapack_int,
u: *mut c_double,
ldu: *const lapack_int,
v: *mut c_double,
ldv: *const lapack_int,
q: *mut c_double,
ldq: *const lapack_int,
iwork: *mut lapack_int,
tau: *mut c_double,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn cggsvp3_(
jobu: *const c_char,
jobv: *const c_char,
jobq: *const c_char,
m: *const lapack_int,
p: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
tola: *const c_float,
tolb: *const c_float,
k: *mut lapack_int,
l: *mut lapack_int,
u: *mut lapack_complex_float,
ldu: *const lapack_int,
v: *mut lapack_complex_float,
ldv: *const lapack_int,
q: *mut lapack_complex_float,
ldq: *const lapack_int,
iwork: *mut lapack_int,
rwork: *mut c_float,
tau: *mut lapack_complex_float,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zggsvp3_(
jobu: *const c_char,
jobv: *const c_char,
jobq: *const c_char,
m: *const lapack_int,
p: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
tola: *const c_double,
tolb: *const c_double,
k: *mut lapack_int,
l: *mut lapack_int,
u: *mut lapack_complex_double,
ldu: *const lapack_int,
v: *mut lapack_complex_double,
ldv: *const lapack_int,
q: *mut lapack_complex_double,
ldq: *const lapack_int,
iwork: *mut lapack_int,
rwork: *mut c_double,
tau: *mut lapack_complex_double,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn stgsja_(
jobu: *const c_char,
jobv: *const c_char,
jobq: *const c_char,
m: *const lapack_int,
p: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
l: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
b: *mut c_float,
ldb: *const lapack_int,
tola: *const c_float,
tolb: *const c_float,
alpha: *mut c_float,
beta: *mut c_float,
u: *mut c_float,
ldu: *const lapack_int,
v: *mut c_float,
ldv: *const lapack_int,
q: *mut c_float,
ldq: *const lapack_int,
work: *mut c_float,
ncycle: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dtgsja_(
jobu: *const c_char,
jobv: *const c_char,
jobq: *const c_char,
m: *const lapack_int,
p: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
l: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
b: *mut c_double,
ldb: *const lapack_int,
tola: *const c_double,
tolb: *const c_double,
alpha: *mut c_double,
beta: *mut c_double,
u: *mut c_double,
ldu: *const lapack_int,
v: *mut c_double,
ldv: *const lapack_int,
q: *mut c_double,
ldq: *const lapack_int,
work: *mut c_double,
ncycle: *mut lapack_int,
info: *mut lapack_int,
);
pub fn ctgsja_(
jobu: *const c_char,
jobv: *const c_char,
jobq: *const c_char,
m: *const lapack_int,
p: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
l: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
tola: *const c_float,
tolb: *const c_float,
alpha: *mut c_float,
beta: *mut c_float,
u: *mut lapack_complex_float,
ldu: *const lapack_int,
v: *mut lapack_complex_float,
ldv: *const lapack_int,
q: *mut lapack_complex_float,
ldq: *const lapack_int,
work: *mut lapack_complex_float,
ncycle: *mut lapack_int,
info: *mut lapack_int,
);
pub fn ztgsja_(
jobu: *const c_char,
jobv: *const c_char,
jobq: *const c_char,
m: *const lapack_int,
p: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
l: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
tola: *const c_double,
tolb: *const c_double,
alpha: *mut c_double,
beta: *mut c_double,
u: *mut lapack_complex_double,
ldu: *const lapack_int,
v: *mut lapack_complex_double,
ldv: *const lapack_int,
q: *mut lapack_complex_double,
ldq: *const lapack_int,
work: *mut lapack_complex_double,
ncycle: *mut lapack_int,
info: *mut lapack_int,
);
pub fn sgels_(
trans: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
b: *mut c_float,
ldb: *const lapack_int,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dgels_(
trans: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
b: *mut c_double,
ldb: *const lapack_int,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn cgels_(
trans: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zgels_(
trans: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn sgelsy_(
m: *const lapack_int,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
b: *mut c_float,
ldb: *const lapack_int,
jpvt: *mut lapack_int,
rcond: *const c_float,
rank: *mut lapack_int,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dgelsy_(
m: *const lapack_int,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
b: *mut c_double,
ldb: *const lapack_int,
jpvt: *mut lapack_int,
rcond: *const c_double,
rank: *mut lapack_int,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn cgelsy_(
m: *const lapack_int,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
jpvt: *mut lapack_int,
rcond: *const c_float,
rank: *mut lapack_int,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn zgelsy_(
m: *const lapack_int,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
jpvt: *mut lapack_int,
rcond: *const c_double,
rank: *mut lapack_int,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn sgelss_(
m: *const lapack_int,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
b: *mut c_float,
ldb: *const lapack_int,
s: *mut c_float,
rcond: *const c_float,
rank: *mut lapack_int,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dgelss_(
m: *const lapack_int,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
b: *mut c_double,
ldb: *const lapack_int,
s: *mut c_double,
rcond: *const c_double,
rank: *mut lapack_int,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn cgelss_(
m: *const lapack_int,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
s: *mut c_float,
rcond: *const c_float,
rank: *mut lapack_int,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn zgelss_(
m: *const lapack_int,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
s: *mut c_double,
rcond: *const c_double,
rank: *mut lapack_int,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn sgelsd_(
m: *const lapack_int,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const c_float,
lda: *const lapack_int,
b: *mut c_float,
ldb: *const lapack_int,
s: *mut c_float,
rcond: *const c_float,
rank: *mut lapack_int,
work: *mut c_float,
lwork: *const lapack_int,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dgelsd_(
m: *const lapack_int,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const c_double,
lda: *const lapack_int,
b: *mut c_double,
ldb: *const lapack_int,
s: *mut c_double,
rcond: *const c_double,
rank: *mut lapack_int,
work: *mut c_double,
lwork: *const lapack_int,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn cgelsd_(
m: *const lapack_int,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
s: *mut c_float,
rcond: *const c_float,
rank: *mut lapack_int,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
rwork: *mut c_float,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn zgelsd_(
m: *const lapack_int,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
s: *mut c_double,
rcond: *const c_double,
rank: *mut lapack_int,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
rwork: *mut c_double,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn sgglse_(
m: *const lapack_int,
n: *const lapack_int,
p: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
b: *mut c_float,
ldb: *const lapack_int,
c: *mut c_float,
d: *mut c_float,
x: *mut c_float,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dgglse_(
m: *const lapack_int,
n: *const lapack_int,
p: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
b: *mut c_double,
ldb: *const lapack_int,
c: *mut c_double,
d: *mut c_double,
x: *mut c_double,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn cgglse_(
m: *const lapack_int,
n: *const lapack_int,
p: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
c: *mut lapack_complex_float,
d: *mut lapack_complex_float,
x: *mut lapack_complex_float,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zgglse_(
m: *const lapack_int,
n: *const lapack_int,
p: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
c: *mut lapack_complex_double,
d: *mut lapack_complex_double,
x: *mut lapack_complex_double,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn sggglm_(
n: *const lapack_int,
m: *const lapack_int,
p: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
b: *mut c_float,
ldb: *const lapack_int,
d: *mut c_float,
x: *mut c_float,
y: *mut c_float,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dggglm_(
n: *const lapack_int,
m: *const lapack_int,
p: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
b: *mut c_double,
ldb: *const lapack_int,
d: *mut c_double,
x: *mut c_double,
y: *mut c_double,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn cggglm_(
n: *const lapack_int,
m: *const lapack_int,
p: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
d: *mut lapack_complex_float,
x: *mut lapack_complex_float,
y: *mut lapack_complex_float,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zggglm_(
n: *const lapack_int,
m: *const lapack_int,
p: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
d: *mut lapack_complex_double,
x: *mut lapack_complex_double,
y: *mut lapack_complex_double,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn ssyev_(
jobz: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
w: *mut c_float,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dsyev_(
jobz: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
w: *mut c_double,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn cheev_(
jobz: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
w: *mut c_float,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn zheev_(
jobz: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
w: *mut c_double,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn ssyevd_(
jobz: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
w: *mut c_float,
work: *mut c_float,
lwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dsyevd_(
jobz: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
w: *mut c_double,
work: *mut c_double,
lwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn cheevd_(
jobz: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
w: *mut c_float,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
rwork: *mut c_float,
lrwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zheevd_(
jobz: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
w: *mut c_double,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
rwork: *mut c_double,
lrwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn ssyevx_(
jobz: *const c_char,
range: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
vl: *const c_float,
vu: *const c_float,
il: *const lapack_int,
iu: *const lapack_int,
abstol: *const c_float,
m: *mut lapack_int,
w: *mut c_float,
z: *mut c_float,
ldz: *const lapack_int,
work: *mut c_float,
lwork: *const lapack_int,
iwork: *mut lapack_int,
ifail: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dsyevx_(
jobz: *const c_char,
range: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
vl: *const c_double,
vu: *const c_double,
il: *const lapack_int,
iu: *const lapack_int,
abstol: *const c_double,
m: *mut lapack_int,
w: *mut c_double,
z: *mut c_double,
ldz: *const lapack_int,
work: *mut c_double,
lwork: *const lapack_int,
iwork: *mut lapack_int,
ifail: *mut lapack_int,
info: *mut lapack_int,
);
pub fn cheevx_(
jobz: *const c_char,
range: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
vl: *const c_float,
vu: *const c_float,
il: *const lapack_int,
iu: *const lapack_int,
abstol: *const c_float,
m: *mut lapack_int,
w: *mut c_float,
z: *mut lapack_complex_float,
ldz: *const lapack_int,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
rwork: *mut c_float,
iwork: *mut lapack_int,
ifail: *mut lapack_int,
info: *mut lapack_int,
);
pub fn zheevx_(
jobz: *const c_char,
range: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
vl: *const c_double,
vu: *const c_double,
il: *const lapack_int,
iu: *const lapack_int,
abstol: *const c_double,
m: *mut lapack_int,
w: *mut c_double,
z: *mut lapack_complex_double,
ldz: *const lapack_int,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
rwork: *mut c_double,
iwork: *mut lapack_int,
ifail: *mut lapack_int,
info: *mut lapack_int,
);
pub fn ssyevr_(
jobz: *const c_char,
range: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
vl: *const c_float,
vu: *const c_float,
il: *const lapack_int,
iu: *const lapack_int,
abstol: *const c_float,
m: *mut lapack_int,
w: *mut c_float,
z: *mut c_float,
ldz: *const lapack_int,
isuppz: *mut lapack_int,
work: *mut c_float,
lwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dsyevr_(
jobz: *const c_char,
range: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
vl: *const c_double,
vu: *const c_double,
il: *const lapack_int,
iu: *const lapack_int,
abstol: *const c_double,
m: *mut lapack_int,
w: *mut c_double,
z: *mut c_double,
ldz: *const lapack_int,
isuppz: *mut lapack_int,
work: *mut c_double,
lwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn cheevr_(
jobz: *const c_char,
range: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
vl: *const c_float,
vu: *const c_float,
il: *const lapack_int,
iu: *const lapack_int,
abstol: *const c_float,
m: *mut lapack_int,
w: *mut c_float,
z: *mut lapack_complex_float,
ldz: *const lapack_int,
isuppz: *mut lapack_int,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
rwork: *mut c_float,
lrwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zheevr_(
jobz: *const c_char,
range: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
vl: *const c_double,
vu: *const c_double,
il: *const lapack_int,
iu: *const lapack_int,
abstol: *const c_double,
m: *mut lapack_int,
w: *mut c_double,
z: *mut lapack_complex_double,
ldz: *const lapack_int,
isuppz: *mut lapack_int,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
rwork: *mut c_double,
lrwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn sspev_(
jobz: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
ap: *mut c_float,
w: *mut c_float,
z: *mut c_float,
ldz: *const lapack_int,
work: *mut c_float,
info: *mut lapack_int,
);
pub fn dspev_(
jobz: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
ap: *mut c_double,
w: *mut c_double,
z: *mut c_double,
ldz: *const lapack_int,
work: *mut c_double,
info: *mut lapack_int,
);
pub fn chpev_(
jobz: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
ap: *mut lapack_complex_float,
w: *mut c_float,
z: *mut lapack_complex_float,
ldz: *const lapack_int,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn zhpev_(
jobz: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
ap: *mut lapack_complex_double,
w: *mut c_double,
z: *mut lapack_complex_double,
ldz: *const lapack_int,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn sspevd_(
jobz: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
ap: *mut c_float,
w: *mut c_float,
z: *mut c_float,
ldz: *const lapack_int,
work: *mut c_float,
lwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dspevd_(
jobz: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
ap: *mut c_double,
w: *mut c_double,
z: *mut c_double,
ldz: *const lapack_int,
work: *mut c_double,
lwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn chpevd_(
jobz: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
ap: *mut lapack_complex_float,
w: *mut c_float,
z: *mut lapack_complex_float,
ldz: *const lapack_int,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
rwork: *mut c_float,
lrwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zhpevd_(
jobz: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
ap: *mut lapack_complex_double,
w: *mut c_double,
z: *mut lapack_complex_double,
ldz: *const lapack_int,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
rwork: *mut c_double,
lrwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn sspevx_(
jobz: *const c_char,
range: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
ap: *mut c_float,
vl: *const c_float,
vu: *const c_float,
il: *const lapack_int,
iu: *const lapack_int,
abstol: *const c_float,
m: *mut lapack_int,
w: *mut c_float,
z: *mut c_float,
ldz: *const lapack_int,
work: *mut c_float,
iwork: *mut lapack_int,
ifail: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dspevx_(
jobz: *const c_char,
range: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
ap: *mut c_double,
vl: *const c_double,
vu: *const c_double,
il: *const lapack_int,
iu: *const lapack_int,
abstol: *const c_double,
m: *mut lapack_int,
w: *mut c_double,
z: *mut c_double,
ldz: *const lapack_int,
work: *mut c_double,
iwork: *mut lapack_int,
ifail: *mut lapack_int,
info: *mut lapack_int,
);
pub fn chpevx_(
jobz: *const c_char,
range: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
ap: *mut lapack_complex_float,
vl: *const c_float,
vu: *const c_float,
il: *const lapack_int,
iu: *const lapack_int,
abstol: *const c_float,
m: *mut lapack_int,
w: *mut c_float,
z: *mut lapack_complex_float,
ldz: *const lapack_int,
work: *mut lapack_complex_float,
rwork: *mut c_float,
iwork: *mut lapack_int,
ifail: *mut lapack_int,
info: *mut lapack_int,
);
pub fn zhpevx_(
jobz: *const c_char,
range: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
ap: *mut lapack_complex_double,
vl: *const c_double,
vu: *const c_double,
il: *const lapack_int,
iu: *const lapack_int,
abstol: *const c_double,
m: *mut lapack_int,
w: *mut c_double,
z: *mut lapack_complex_double,
ldz: *const lapack_int,
work: *mut lapack_complex_double,
rwork: *mut c_double,
iwork: *mut lapack_int,
ifail: *mut lapack_int,
info: *mut lapack_int,
);
pub fn ssbev_(
jobz: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
ab: *mut c_float,
ldab: *const lapack_int,
w: *mut c_float,
z: *mut c_float,
ldz: *const lapack_int,
work: *mut c_float,
info: *mut lapack_int,
);
pub fn dsbev_(
jobz: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
ab: *mut c_double,
ldab: *const lapack_int,
w: *mut c_double,
z: *mut c_double,
ldz: *const lapack_int,
work: *mut c_double,
info: *mut lapack_int,
);
pub fn chbev_(
jobz: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
ab: *mut lapack_complex_float,
ldab: *const lapack_int,
w: *mut c_float,
z: *mut lapack_complex_float,
ldz: *const lapack_int,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn zhbev_(
jobz: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
ab: *mut lapack_complex_double,
ldab: *const lapack_int,
w: *mut c_double,
z: *mut lapack_complex_double,
ldz: *const lapack_int,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn ssbevd_(
jobz: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
ab: *mut c_float,
ldab: *const lapack_int,
w: *mut c_float,
z: *mut c_float,
ldz: *const lapack_int,
work: *mut c_float,
lwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dsbevd_(
jobz: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
ab: *mut c_double,
ldab: *const lapack_int,
w: *mut c_double,
z: *mut c_double,
ldz: *const lapack_int,
work: *mut c_double,
lwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn chbevd_(
jobz: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
ab: *mut lapack_complex_float,
ldab: *const lapack_int,
w: *mut c_float,
z: *mut lapack_complex_float,
ldz: *const lapack_int,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
rwork: *mut c_float,
lrwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zhbevd_(
jobz: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
ab: *mut lapack_complex_double,
ldab: *const lapack_int,
w: *mut c_double,
z: *mut lapack_complex_double,
ldz: *const lapack_int,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
rwork: *mut c_double,
lrwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn ssbevx_(
jobz: *const c_char,
range: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
ab: *mut c_float,
ldab: *const lapack_int,
q: *mut c_float,
ldq: *const lapack_int,
vl: *const c_float,
vu: *const c_float,
il: *const lapack_int,
iu: *const lapack_int,
abstol: *const c_float,
m: *mut lapack_int,
w: *mut c_float,
z: *mut c_float,
ldz: *const lapack_int,
work: *mut c_float,
iwork: *mut lapack_int,
ifail: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dsbevx_(
jobz: *const c_char,
range: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
ab: *mut c_double,
ldab: *const lapack_int,
q: *mut c_double,
ldq: *const lapack_int,
vl: *const c_double,
vu: *const c_double,
il: *const lapack_int,
iu: *const lapack_int,
abstol: *const c_double,
m: *mut lapack_int,
w: *mut c_double,
z: *mut c_double,
ldz: *const lapack_int,
work: *mut c_double,
iwork: *mut lapack_int,
ifail: *mut lapack_int,
info: *mut lapack_int,
);
pub fn chbevx_(
jobz: *const c_char,
range: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
ab: *mut lapack_complex_float,
ldab: *const lapack_int,
q: *mut lapack_complex_float,
ldq: *const lapack_int,
vl: *const c_float,
vu: *const c_float,
il: *const lapack_int,
iu: *const lapack_int,
abstol: *const c_float,
m: *mut lapack_int,
w: *mut c_float,
z: *mut lapack_complex_float,
ldz: *const lapack_int,
work: *mut lapack_complex_float,
rwork: *mut c_float,
iwork: *mut lapack_int,
ifail: *mut lapack_int,
info: *mut lapack_int,
);
pub fn zhbevx_(
jobz: *const c_char,
range: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
kd: *const lapack_int,
ab: *mut lapack_complex_double,
ldab: *const lapack_int,
q: *mut lapack_complex_double,
ldq: *const lapack_int,
vl: *const c_double,
vu: *const c_double,
il: *const lapack_int,
iu: *const lapack_int,
abstol: *const c_double,
m: *mut lapack_int,
w: *mut c_double,
z: *mut lapack_complex_double,
ldz: *const lapack_int,
work: *mut lapack_complex_double,
rwork: *mut c_double,
iwork: *mut lapack_int,
ifail: *mut lapack_int,
info: *mut lapack_int,
);
pub fn sstev_(
jobz: *const c_char,
n: *const lapack_int,
d: *mut c_float,
e: *mut c_float,
z: *mut c_float,
ldz: *const lapack_int,
work: *mut c_float,
info: *mut lapack_int,
);
pub fn dstev_(
jobz: *const c_char,
n: *const lapack_int,
d: *mut c_double,
e: *mut c_double,
z: *mut c_double,
ldz: *const lapack_int,
work: *mut c_double,
info: *mut lapack_int,
);
pub fn sstevd_(
jobz: *const c_char,
n: *const lapack_int,
d: *mut c_float,
e: *mut c_float,
z: *mut c_float,
ldz: *const lapack_int,
work: *mut c_float,
lwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dstevd_(
jobz: *const c_char,
n: *const lapack_int,
d: *mut c_double,
e: *mut c_double,
z: *mut c_double,
ldz: *const lapack_int,
work: *mut c_double,
lwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn sstevx_(
jobz: *const c_char,
range: *const c_char,
n: *const lapack_int,
d: *mut c_float,
e: *mut c_float,
vl: *const c_float,
vu: *const c_float,
il: *const lapack_int,
iu: *const lapack_int,
abstol: *const c_float,
m: *mut lapack_int,
w: *mut c_float,
z: *mut c_float,
ldz: *const lapack_int,
work: *mut c_float,
iwork: *mut lapack_int,
ifail: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dstevx_(
jobz: *const c_char,
range: *const c_char,
n: *const lapack_int,
d: *mut c_double,
e: *mut c_double,
vl: *const c_double,
vu: *const c_double,
il: *const lapack_int,
iu: *const lapack_int,
abstol: *const c_double,
m: *mut lapack_int,
w: *mut c_double,
z: *mut c_double,
ldz: *const lapack_int,
work: *mut c_double,
iwork: *mut lapack_int,
ifail: *mut lapack_int,
info: *mut lapack_int,
);
pub fn sstevr_(
jobz: *const c_char,
range: *const c_char,
n: *const lapack_int,
d: *mut c_float,
e: *mut c_float,
vl: *const c_float,
vu: *const c_float,
il: *const lapack_int,
iu: *const lapack_int,
abstol: *const c_float,
m: *mut lapack_int,
w: *mut c_float,
z: *mut c_float,
ldz: *const lapack_int,
isuppz: *mut lapack_int,
work: *mut c_float,
lwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dstevr_(
jobz: *const c_char,
range: *const c_char,
n: *const lapack_int,
d: *mut c_double,
e: *mut c_double,
vl: *const c_double,
vu: *const c_double,
il: *const lapack_int,
iu: *const lapack_int,
abstol: *const c_double,
m: *mut lapack_int,
w: *mut c_double,
z: *mut c_double,
ldz: *const lapack_int,
isuppz: *mut lapack_int,
work: *mut c_double,
lwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn sgees_(
jobvs: *const c_char,
sort: *const c_char,
select: LAPACK_S_SELECT2,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
sdim: *mut lapack_int,
wr: *mut c_float,
wi: *mut c_float,
vs: *mut c_float,
ldvs: *const lapack_int,
work: *mut c_float,
lwork: *const lapack_int,
bwork: *mut lapack_logical,
info: *mut lapack_int,
);
pub fn dgees_(
jobvs: *const c_char,
sort: *const c_char,
select: LAPACK_D_SELECT2,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
sdim: *mut lapack_int,
wr: *mut c_double,
wi: *mut c_double,
vs: *mut c_double,
ldvs: *const lapack_int,
work: *mut c_double,
lwork: *const lapack_int,
bwork: *mut lapack_logical,
info: *mut lapack_int,
);
pub fn cgees_(
jobvs: *const c_char,
sort: *const c_char,
select: LAPACK_C_SELECT1,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
sdim: *mut lapack_int,
w: *mut lapack_complex_float,
vs: *mut lapack_complex_float,
ldvs: *const lapack_int,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
rwork: *mut c_float,
bwork: *mut lapack_logical,
info: *mut lapack_int,
);
pub fn zgees_(
jobvs: *const c_char,
sort: *const c_char,
select: LAPACK_Z_SELECT1,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
sdim: *mut lapack_int,
w: *mut lapack_complex_double,
vs: *mut lapack_complex_double,
ldvs: *const lapack_int,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
rwork: *mut c_double,
bwork: *mut lapack_logical,
info: *mut lapack_int,
);
pub fn sgeesx_(
jobvs: *const c_char,
sort: *const c_char,
select: LAPACK_S_SELECT2,
sense: *const c_char,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
sdim: *mut lapack_int,
wr: *mut c_float,
wi: *mut c_float,
vs: *mut c_float,
ldvs: *const lapack_int,
rconde: *mut c_float,
rcondv: *mut c_float,
work: *mut c_float,
lwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
bwork: *mut lapack_logical,
info: *mut lapack_int,
);
pub fn dgeesx_(
jobvs: *const c_char,
sort: *const c_char,
select: LAPACK_D_SELECT2,
sense: *const c_char,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
sdim: *mut lapack_int,
wr: *mut c_double,
wi: *mut c_double,
vs: *mut c_double,
ldvs: *const lapack_int,
rconde: *mut c_double,
rcondv: *mut c_double,
work: *mut c_double,
lwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
bwork: *mut lapack_logical,
info: *mut lapack_int,
);
pub fn cgeesx_(
jobvs: *const c_char,
sort: *const c_char,
select: LAPACK_C_SELECT1,
sense: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
sdim: *mut lapack_int,
w: *mut lapack_complex_float,
vs: *mut lapack_complex_float,
ldvs: *const lapack_int,
rconde: *mut c_float,
rcondv: *mut c_float,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
rwork: *mut c_float,
bwork: *mut lapack_logical,
info: *mut lapack_int,
);
pub fn zgeesx_(
jobvs: *const c_char,
sort: *const c_char,
select: LAPACK_Z_SELECT1,
sense: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
sdim: *mut lapack_int,
w: *mut lapack_complex_double,
vs: *mut lapack_complex_double,
ldvs: *const lapack_int,
rconde: *mut c_double,
rcondv: *mut c_double,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
rwork: *mut c_double,
bwork: *mut lapack_logical,
info: *mut lapack_int,
);
pub fn sgeev_(
jobvl: *const c_char,
jobvr: *const c_char,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
wr: *mut c_float,
wi: *mut c_float,
vl: *mut c_float,
ldvl: *const lapack_int,
vr: *mut c_float,
ldvr: *const lapack_int,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dgeev_(
jobvl: *const c_char,
jobvr: *const c_char,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
wr: *mut c_double,
wi: *mut c_double,
vl: *mut c_double,
ldvl: *const lapack_int,
vr: *mut c_double,
ldvr: *const lapack_int,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn cgeev_(
jobvl: *const c_char,
jobvr: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
w: *mut lapack_complex_float,
vl: *mut lapack_complex_float,
ldvl: *const lapack_int,
vr: *mut lapack_complex_float,
ldvr: *const lapack_int,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn zgeev_(
jobvl: *const c_char,
jobvr: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
w: *mut lapack_complex_double,
vl: *mut lapack_complex_double,
ldvl: *const lapack_int,
vr: *mut lapack_complex_double,
ldvr: *const lapack_int,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn sgeevx_(
balanc: *const c_char,
jobvl: *const c_char,
jobvr: *const c_char,
sense: *const c_char,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
wr: *mut c_float,
wi: *mut c_float,
vl: *mut c_float,
ldvl: *const lapack_int,
vr: *mut c_float,
ldvr: *const lapack_int,
ilo: *mut lapack_int,
ihi: *mut lapack_int,
scale: *mut c_float,
abnrm: *mut c_float,
rconde: *mut c_float,
rcondv: *mut c_float,
work: *mut c_float,
lwork: *const lapack_int,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dgeevx_(
balanc: *const c_char,
jobvl: *const c_char,
jobvr: *const c_char,
sense: *const c_char,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
wr: *mut c_double,
wi: *mut c_double,
vl: *mut c_double,
ldvl: *const lapack_int,
vr: *mut c_double,
ldvr: *const lapack_int,
ilo: *mut lapack_int,
ihi: *mut lapack_int,
scale: *mut c_double,
abnrm: *mut c_double,
rconde: *mut c_double,
rcondv: *mut c_double,
work: *mut c_double,
lwork: *const lapack_int,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn cgeevx_(
balanc: *const c_char,
jobvl: *const c_char,
jobvr: *const c_char,
sense: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
w: *mut lapack_complex_float,
vl: *mut lapack_complex_float,
ldvl: *const lapack_int,
vr: *mut lapack_complex_float,
ldvr: *const lapack_int,
ilo: *mut lapack_int,
ihi: *mut lapack_int,
scale: *mut c_float,
abnrm: *mut c_float,
rconde: *mut c_float,
rcondv: *mut c_float,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn zgeevx_(
balanc: *const c_char,
jobvl: *const c_char,
jobvr: *const c_char,
sense: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
w: *mut lapack_complex_double,
vl: *mut lapack_complex_double,
ldvl: *const lapack_int,
vr: *mut lapack_complex_double,
ldvr: *const lapack_int,
ilo: *mut lapack_int,
ihi: *mut lapack_int,
scale: *mut c_double,
abnrm: *mut c_double,
rconde: *mut c_double,
rcondv: *mut c_double,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn sgesvd_(
jobu: *const c_char,
jobvt: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
s: *mut c_float,
u: *mut c_float,
ldu: *const lapack_int,
vt: *mut c_float,
ldvt: *const lapack_int,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dgesvd_(
jobu: *const c_char,
jobvt: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
s: *mut c_double,
u: *mut c_double,
ldu: *const lapack_int,
vt: *mut c_double,
ldvt: *const lapack_int,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn cgesvd_(
jobu: *const c_char,
jobvt: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
s: *mut c_float,
u: *mut lapack_complex_float,
ldu: *const lapack_int,
vt: *mut lapack_complex_float,
ldvt: *const lapack_int,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn zgesvd_(
jobu: *const c_char,
jobvt: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
s: *mut c_double,
u: *mut lapack_complex_double,
ldu: *const lapack_int,
vt: *mut lapack_complex_double,
ldvt: *const lapack_int,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn sgesvdx_(
jobu: *const c_char,
jobvt: *const c_char,
range: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
vl: *const c_float,
vu: *const c_float,
il: *const lapack_int,
iu: *const lapack_int,
ns: *mut lapack_int,
s: *mut c_float,
u: *mut c_float,
ldu: *const lapack_int,
vt: *mut c_float,
ldvt: *const lapack_int,
work: *mut c_float,
lwork: *const lapack_int,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dgesvdx_(
jobu: *const c_char,
jobvt: *const c_char,
range: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
vl: *const c_double,
vu: *const c_double,
il: *const lapack_int,
iu: *const lapack_int,
ns: *mut lapack_int,
s: *mut c_double,
u: *mut c_double,
ldu: *const lapack_int,
vt: *mut c_double,
ldvt: *const lapack_int,
work: *mut c_double,
lwork: *const lapack_int,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn cgesvdx_(
jobu: *const c_char,
jobvt: *const c_char,
range: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
vl: *const c_float,
vu: *const c_float,
il: *const lapack_int,
iu: *const lapack_int,
ns: *mut lapack_int,
s: *mut c_float,
u: *mut lapack_complex_float,
ldu: *const lapack_int,
vt: *mut lapack_complex_float,
ldvt: *const lapack_int,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
rwork: *mut c_float,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn zgesvdx_(
jobu: *const c_char,
jobvt: *const c_char,
range: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
vl: *const c_double,
vu: *const c_double,
il: *const lapack_int,
iu: *const lapack_int,
ns: *mut lapack_int,
s: *mut c_double,
u: *mut lapack_complex_double,
ldu: *const lapack_int,
vt: *mut lapack_complex_double,
ldvt: *const lapack_int,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
rwork: *mut c_double,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn sgesdd_(
jobz: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
s: *mut c_float,
u: *mut c_float,
ldu: *const lapack_int,
vt: *mut c_float,
ldvt: *const lapack_int,
work: *mut c_float,
lwork: *const lapack_int,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dgesdd_(
jobz: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
s: *mut c_double,
u: *mut c_double,
ldu: *const lapack_int,
vt: *mut c_double,
ldvt: *const lapack_int,
work: *mut c_double,
lwork: *const lapack_int,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn cgesdd_(
jobz: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
s: *mut c_float,
u: *mut lapack_complex_float,
ldu: *const lapack_int,
vt: *mut lapack_complex_float,
ldvt: *const lapack_int,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
rwork: *mut c_float,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn zgesdd_(
jobz: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
s: *mut c_double,
u: *mut lapack_complex_double,
ldu: *const lapack_int,
vt: *mut lapack_complex_double,
ldvt: *const lapack_int,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
rwork: *mut c_double,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dgejsv_(
joba: *const c_char,
jobu: *const c_char,
jobv: *const c_char,
jobr: *const c_char,
jobt: *const c_char,
jobp: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
sva: *mut c_double,
u: *mut c_double,
ldu: *const lapack_int,
v: *mut c_double,
ldv: *const lapack_int,
work: *mut c_double,
lwork: *const lapack_int,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn sgejsv_(
joba: *const c_char,
jobu: *const c_char,
jobv: *const c_char,
jobr: *const c_char,
jobt: *const c_char,
jobp: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
sva: *mut c_float,
u: *mut c_float,
ldu: *const lapack_int,
v: *mut c_float,
ldv: *const lapack_int,
work: *mut c_float,
lwork: *const lapack_int,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn cgejsv_(
joba: *const c_char,
jobu: *const c_char,
jobv: *const c_char,
jobr: *const c_char,
jobt: *const c_char,
jobp: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
sva: *mut c_float,
u: *mut lapack_complex_float,
ldu: *const lapack_int,
v: *mut lapack_complex_float,
ldv: *const lapack_int,
cwork: *mut lapack_complex_float,
lwork: *const lapack_int,
work: *mut c_float,
lrwork: *const lapack_int,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn zgejsv_(
joba: *const c_char,
jobu: *const c_char,
jobv: *const c_char,
jobr: *const c_char,
jobt: *const c_char,
jobp: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
sva: *mut c_double,
u: *mut lapack_complex_double,
ldu: *const lapack_int,
v: *mut lapack_complex_double,
ldv: *const lapack_int,
cwork: *mut lapack_complex_double,
lwork: *const lapack_int,
work: *mut c_double,
lrwork: *const lapack_int,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dgesvj_(
joba: *const c_char,
jobu: *const c_char,
jobv: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
sva: *mut c_double,
mv: *const lapack_int,
v: *mut c_double,
ldv: *const lapack_int,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn sgesvj_(
joba: *const c_char,
jobu: *const c_char,
jobv: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
sva: *mut c_float,
mv: *const lapack_int,
v: *mut c_float,
ldv: *const lapack_int,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn cgesvj_(
joba: *const c_char,
jobu: *const c_char,
jobv: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
sva: *mut c_float,
mv: *const lapack_int,
v: *mut lapack_complex_float,
ldv: *const lapack_int,
cwork: *mut lapack_complex_float,
lwork: *const lapack_int,
rwork: *mut c_float,
lrwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zgesvj_(
joba: *const c_char,
jobu: *const c_char,
jobv: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
sva: *mut c_double,
mv: *const lapack_int,
v: *mut lapack_complex_double,
ldv: *const lapack_int,
cwork: *mut lapack_complex_double,
lwork: *const lapack_int,
rwork: *mut c_double,
lrwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn sggsvd_(
jobu: *const c_char,
jobv: *const c_char,
jobq: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
p: *const lapack_int,
k: *mut lapack_int,
l: *mut lapack_int,
a: *mut c_float,
lda: *const lapack_int,
b: *mut c_float,
ldb: *const lapack_int,
alpha: *mut c_float,
beta: *mut c_float,
u: *mut c_float,
ldu: *const lapack_int,
v: *mut c_float,
ldv: *const lapack_int,
q: *mut c_float,
ldq: *const lapack_int,
work: *mut c_float,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dggsvd_(
jobu: *const c_char,
jobv: *const c_char,
jobq: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
p: *const lapack_int,
k: *mut lapack_int,
l: *mut lapack_int,
a: *mut c_double,
lda: *const lapack_int,
b: *mut c_double,
ldb: *const lapack_int,
alpha: *mut c_double,
beta: *mut c_double,
u: *mut c_double,
ldu: *const lapack_int,
v: *mut c_double,
ldv: *const lapack_int,
q: *mut c_double,
ldq: *const lapack_int,
work: *mut c_double,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn cggsvd_(
jobu: *const c_char,
jobv: *const c_char,
jobq: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
p: *const lapack_int,
k: *mut lapack_int,
l: *mut lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
alpha: *mut c_float,
beta: *mut c_float,
u: *mut lapack_complex_float,
ldu: *const lapack_int,
v: *mut lapack_complex_float,
ldv: *const lapack_int,
q: *mut lapack_complex_float,
ldq: *const lapack_int,
work: *mut lapack_complex_float,
rwork: *mut c_float,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn zggsvd_(
jobu: *const c_char,
jobv: *const c_char,
jobq: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
p: *const lapack_int,
k: *mut lapack_int,
l: *mut lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
alpha: *mut c_double,
beta: *mut c_double,
u: *mut lapack_complex_double,
ldu: *const lapack_int,
v: *mut lapack_complex_double,
ldv: *const lapack_int,
q: *mut lapack_complex_double,
ldq: *const lapack_int,
work: *mut lapack_complex_double,
rwork: *mut c_double,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn sggsvd3_(
jobu: *const c_char,
jobv: *const c_char,
jobq: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
p: *const lapack_int,
k: *mut lapack_int,
l: *mut lapack_int,
a: *mut c_float,
lda: *const lapack_int,
b: *mut c_float,
ldb: *const lapack_int,
alpha: *mut c_float,
beta: *mut c_float,
u: *mut c_float,
ldu: *const lapack_int,
v: *mut c_float,
ldv: *const lapack_int,
q: *mut c_float,
ldq: *const lapack_int,
work: *mut c_float,
lwork: *const lapack_int,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dggsvd3_(
jobu: *const c_char,
jobv: *const c_char,
jobq: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
p: *const lapack_int,
k: *mut lapack_int,
l: *mut lapack_int,
a: *mut c_double,
lda: *const lapack_int,
b: *mut c_double,
ldb: *const lapack_int,
alpha: *mut c_double,
beta: *mut c_double,
u: *mut c_double,
ldu: *const lapack_int,
v: *mut c_double,
ldv: *const lapack_int,
q: *mut c_double,
ldq: *const lapack_int,
work: *mut c_double,
lwork: *const lapack_int,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn cggsvd3_(
jobu: *const c_char,
jobv: *const c_char,
jobq: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
p: *const lapack_int,
k: *mut lapack_int,
l: *mut lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
alpha: *mut c_float,
beta: *mut c_float,
u: *mut lapack_complex_float,
ldu: *const lapack_int,
v: *mut lapack_complex_float,
ldv: *const lapack_int,
q: *mut lapack_complex_float,
ldq: *const lapack_int,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
rwork: *mut c_float,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn zggsvd3_(
jobu: *const c_char,
jobv: *const c_char,
jobq: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
p: *const lapack_int,
k: *mut lapack_int,
l: *mut lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
alpha: *mut c_double,
beta: *mut c_double,
u: *mut lapack_complex_double,
ldu: *const lapack_int,
v: *mut lapack_complex_double,
ldv: *const lapack_int,
q: *mut lapack_complex_double,
ldq: *const lapack_int,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
rwork: *mut c_double,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn ssygv_(
itype: *const lapack_int,
jobz: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
b: *mut c_float,
ldb: *const lapack_int,
w: *mut c_float,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dsygv_(
itype: *const lapack_int,
jobz: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
b: *mut c_double,
ldb: *const lapack_int,
w: *mut c_double,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn chegv_(
itype: *const lapack_int,
jobz: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
w: *mut c_float,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn zhegv_(
itype: *const lapack_int,
jobz: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
w: *mut c_double,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn ssygvd_(
itype: *const lapack_int,
jobz: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
b: *mut c_float,
ldb: *const lapack_int,
w: *mut c_float,
work: *mut c_float,
lwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dsygvd_(
itype: *const lapack_int,
jobz: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
b: *mut c_double,
ldb: *const lapack_int,
w: *mut c_double,
work: *mut c_double,
lwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn chegvd_(
itype: *const lapack_int,
jobz: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
w: *mut c_float,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
rwork: *mut c_float,
lrwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zhegvd_(
itype: *const lapack_int,
jobz: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
w: *mut c_double,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
rwork: *mut c_double,
lrwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn ssygvx_(
itype: *const lapack_int,
jobz: *const c_char,
range: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
b: *mut c_float,
ldb: *const lapack_int,
vl: *const c_float,
vu: *const c_float,
il: *const lapack_int,
iu: *const lapack_int,
abstol: *const c_float,
m: *mut lapack_int,
w: *mut c_float,
z: *mut c_float,
ldz: *const lapack_int,
work: *mut c_float,
lwork: *const lapack_int,
iwork: *mut lapack_int,
ifail: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dsygvx_(
itype: *const lapack_int,
jobz: *const c_char,
range: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
b: *mut c_double,
ldb: *const lapack_int,
vl: *const c_double,
vu: *const c_double,
il: *const lapack_int,
iu: *const lapack_int,
abstol: *const c_double,
m: *mut lapack_int,
w: *mut c_double,
z: *mut c_double,
ldz: *const lapack_int,
work: *mut c_double,
lwork: *const lapack_int,
iwork: *mut lapack_int,
ifail: *mut lapack_int,
info: *mut lapack_int,
);
pub fn chegvx_(
itype: *const lapack_int,
jobz: *const c_char,
range: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
vl: *const c_float,
vu: *const c_float,
il: *const lapack_int,
iu: *const lapack_int,
abstol: *const c_float,
m: *mut lapack_int,
w: *mut c_float,
z: *mut lapack_complex_float,
ldz: *const lapack_int,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
rwork: *mut c_float,
iwork: *mut lapack_int,
ifail: *mut lapack_int,
info: *mut lapack_int,
);
pub fn zhegvx_(
itype: *const lapack_int,
jobz: *const c_char,
range: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
vl: *const c_double,
vu: *const c_double,
il: *const lapack_int,
iu: *const lapack_int,
abstol: *const c_double,
m: *mut lapack_int,
w: *mut c_double,
z: *mut lapack_complex_double,
ldz: *const lapack_int,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
rwork: *mut c_double,
iwork: *mut lapack_int,
ifail: *mut lapack_int,
info: *mut lapack_int,
);
pub fn sspgv_(
itype: *const lapack_int,
jobz: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
ap: *mut c_float,
bp: *mut c_float,
w: *mut c_float,
z: *mut c_float,
ldz: *const lapack_int,
work: *mut c_float,
info: *mut lapack_int,
);
pub fn dspgv_(
itype: *const lapack_int,
jobz: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
ap: *mut c_double,
bp: *mut c_double,
w: *mut c_double,
z: *mut c_double,
ldz: *const lapack_int,
work: *mut c_double,
info: *mut lapack_int,
);
pub fn chpgv_(
itype: *const lapack_int,
jobz: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
ap: *mut lapack_complex_float,
bp: *mut lapack_complex_float,
w: *mut c_float,
z: *mut lapack_complex_float,
ldz: *const lapack_int,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn zhpgv_(
itype: *const lapack_int,
jobz: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
ap: *mut lapack_complex_double,
bp: *mut lapack_complex_double,
w: *mut c_double,
z: *mut lapack_complex_double,
ldz: *const lapack_int,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn sspgvd_(
itype: *const lapack_int,
jobz: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
ap: *mut c_float,
bp: *mut c_float,
w: *mut c_float,
z: *mut c_float,
ldz: *const lapack_int,
work: *mut c_float,
lwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dspgvd_(
itype: *const lapack_int,
jobz: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
ap: *mut c_double,
bp: *mut c_double,
w: *mut c_double,
z: *mut c_double,
ldz: *const lapack_int,
work: *mut c_double,
lwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn chpgvd_(
itype: *const lapack_int,
jobz: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
ap: *mut lapack_complex_float,
bp: *mut lapack_complex_float,
w: *mut c_float,
z: *mut lapack_complex_float,
ldz: *const lapack_int,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
rwork: *mut c_float,
lrwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zhpgvd_(
itype: *const lapack_int,
jobz: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
ap: *mut lapack_complex_double,
bp: *mut lapack_complex_double,
w: *mut c_double,
z: *mut lapack_complex_double,
ldz: *const lapack_int,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
rwork: *mut c_double,
lrwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn sspgvx_(
itype: *const lapack_int,
jobz: *const c_char,
range: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
ap: *mut c_float,
bp: *mut c_float,
vl: *const c_float,
vu: *const c_float,
il: *const lapack_int,
iu: *const lapack_int,
abstol: *const c_float,
m: *mut lapack_int,
w: *mut c_float,
z: *mut c_float,
ldz: *const lapack_int,
work: *mut c_float,
iwork: *mut lapack_int,
ifail: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dspgvx_(
itype: *const lapack_int,
jobz: *const c_char,
range: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
ap: *mut c_double,
bp: *mut c_double,
vl: *const c_double,
vu: *const c_double,
il: *const lapack_int,
iu: *const lapack_int,
abstol: *const c_double,
m: *mut lapack_int,
w: *mut c_double,
z: *mut c_double,
ldz: *const lapack_int,
work: *mut c_double,
iwork: *mut lapack_int,
ifail: *mut lapack_int,
info: *mut lapack_int,
);
pub fn chpgvx_(
itype: *const lapack_int,
jobz: *const c_char,
range: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
ap: *mut lapack_complex_float,
bp: *mut lapack_complex_float,
vl: *const c_float,
vu: *const c_float,
il: *const lapack_int,
iu: *const lapack_int,
abstol: *const c_float,
m: *mut lapack_int,
w: *mut c_float,
z: *mut lapack_complex_float,
ldz: *const lapack_int,
work: *mut lapack_complex_float,
rwork: *mut c_float,
iwork: *mut lapack_int,
ifail: *mut lapack_int,
info: *mut lapack_int,
);
pub fn zhpgvx_(
itype: *const lapack_int,
jobz: *const c_char,
range: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
ap: *mut lapack_complex_double,
bp: *mut lapack_complex_double,
vl: *const c_double,
vu: *const c_double,
il: *const lapack_int,
iu: *const lapack_int,
abstol: *const c_double,
m: *mut lapack_int,
w: *mut c_double,
z: *mut lapack_complex_double,
ldz: *const lapack_int,
work: *mut lapack_complex_double,
rwork: *mut c_double,
iwork: *mut lapack_int,
ifail: *mut lapack_int,
info: *mut lapack_int,
);
pub fn ssbgv_(
jobz: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
ka: *const lapack_int,
kb: *const lapack_int,
ab: *mut c_float,
ldab: *const lapack_int,
bb: *mut c_float,
ldbb: *const lapack_int,
w: *mut c_float,
z: *mut c_float,
ldz: *const lapack_int,
work: *mut c_float,
info: *mut lapack_int,
);
pub fn dsbgv_(
jobz: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
ka: *const lapack_int,
kb: *const lapack_int,
ab: *mut c_double,
ldab: *const lapack_int,
bb: *mut c_double,
ldbb: *const lapack_int,
w: *mut c_double,
z: *mut c_double,
ldz: *const lapack_int,
work: *mut c_double,
info: *mut lapack_int,
);
pub fn chbgv_(
jobz: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
ka: *const lapack_int,
kb: *const lapack_int,
ab: *mut lapack_complex_float,
ldab: *const lapack_int,
bb: *mut lapack_complex_float,
ldbb: *const lapack_int,
w: *mut c_float,
z: *mut lapack_complex_float,
ldz: *const lapack_int,
work: *mut lapack_complex_float,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn zhbgv_(
jobz: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
ka: *const lapack_int,
kb: *const lapack_int,
ab: *mut lapack_complex_double,
ldab: *const lapack_int,
bb: *mut lapack_complex_double,
ldbb: *const lapack_int,
w: *mut c_double,
z: *mut lapack_complex_double,
ldz: *const lapack_int,
work: *mut lapack_complex_double,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn ssbgvd_(
jobz: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
ka: *const lapack_int,
kb: *const lapack_int,
ab: *mut c_float,
ldab: *const lapack_int,
bb: *mut c_float,
ldbb: *const lapack_int,
w: *mut c_float,
z: *mut c_float,
ldz: *const lapack_int,
work: *mut c_float,
lwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dsbgvd_(
jobz: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
ka: *const lapack_int,
kb: *const lapack_int,
ab: *mut c_double,
ldab: *const lapack_int,
bb: *mut c_double,
ldbb: *const lapack_int,
w: *mut c_double,
z: *mut c_double,
ldz: *const lapack_int,
work: *mut c_double,
lwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn chbgvd_(
jobz: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
ka: *const lapack_int,
kb: *const lapack_int,
ab: *mut lapack_complex_float,
ldab: *const lapack_int,
bb: *mut lapack_complex_float,
ldbb: *const lapack_int,
w: *mut c_float,
z: *mut lapack_complex_float,
ldz: *const lapack_int,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
rwork: *mut c_float,
lrwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zhbgvd_(
jobz: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
ka: *const lapack_int,
kb: *const lapack_int,
ab: *mut lapack_complex_double,
ldab: *const lapack_int,
bb: *mut lapack_complex_double,
ldbb: *const lapack_int,
w: *mut c_double,
z: *mut lapack_complex_double,
ldz: *const lapack_int,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
rwork: *mut c_double,
lrwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn ssbgvx_(
jobz: *const c_char,
range: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
ka: *const lapack_int,
kb: *const lapack_int,
ab: *mut c_float,
ldab: *const lapack_int,
bb: *mut c_float,
ldbb: *const lapack_int,
q: *mut c_float,
ldq: *const lapack_int,
vl: *const c_float,
vu: *const c_float,
il: *const lapack_int,
iu: *const lapack_int,
abstol: *const c_float,
m: *mut lapack_int,
w: *mut c_float,
z: *mut c_float,
ldz: *const lapack_int,
work: *mut c_float,
iwork: *mut lapack_int,
ifail: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dsbgvx_(
jobz: *const c_char,
range: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
ka: *const lapack_int,
kb: *const lapack_int,
ab: *mut c_double,
ldab: *const lapack_int,
bb: *mut c_double,
ldbb: *const lapack_int,
q: *mut c_double,
ldq: *const lapack_int,
vl: *const c_double,
vu: *const c_double,
il: *const lapack_int,
iu: *const lapack_int,
abstol: *const c_double,
m: *mut lapack_int,
w: *mut c_double,
z: *mut c_double,
ldz: *const lapack_int,
work: *mut c_double,
iwork: *mut lapack_int,
ifail: *mut lapack_int,
info: *mut lapack_int,
);
pub fn chbgvx_(
jobz: *const c_char,
range: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
ka: *const lapack_int,
kb: *const lapack_int,
ab: *mut lapack_complex_float,
ldab: *const lapack_int,
bb: *mut lapack_complex_float,
ldbb: *const lapack_int,
q: *mut lapack_complex_float,
ldq: *const lapack_int,
vl: *const c_float,
vu: *const c_float,
il: *const lapack_int,
iu: *const lapack_int,
abstol: *const c_float,
m: *mut lapack_int,
w: *mut c_float,
z: *mut lapack_complex_float,
ldz: *const lapack_int,
work: *mut lapack_complex_float,
rwork: *mut c_float,
iwork: *mut lapack_int,
ifail: *mut lapack_int,
info: *mut lapack_int,
);
pub fn zhbgvx_(
jobz: *const c_char,
range: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
ka: *const lapack_int,
kb: *const lapack_int,
ab: *mut lapack_complex_double,
ldab: *const lapack_int,
bb: *mut lapack_complex_double,
ldbb: *const lapack_int,
q: *mut lapack_complex_double,
ldq: *const lapack_int,
vl: *const c_double,
vu: *const c_double,
il: *const lapack_int,
iu: *const lapack_int,
abstol: *const c_double,
m: *mut lapack_int,
w: *mut c_double,
z: *mut lapack_complex_double,
ldz: *const lapack_int,
work: *mut lapack_complex_double,
rwork: *mut c_double,
iwork: *mut lapack_int,
ifail: *mut lapack_int,
info: *mut lapack_int,
);
pub fn sgges_(
jobvsl: *const c_char,
jobvsr: *const c_char,
sort: *const c_char,
selctg: LAPACK_S_SELECT3,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
b: *mut c_float,
ldb: *const lapack_int,
sdim: *mut lapack_int,
alphar: *mut c_float,
alphai: *mut c_float,
beta: *mut c_float,
vsl: *mut c_float,
ldvsl: *const lapack_int,
vsr: *mut c_float,
ldvsr: *const lapack_int,
work: *mut c_float,
lwork: *const lapack_int,
bwork: *mut lapack_logical,
info: *mut lapack_int,
);
pub fn dgges_(
jobvsl: *const c_char,
jobvsr: *const c_char,
sort: *const c_char,
selctg: LAPACK_D_SELECT3,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
b: *mut c_double,
ldb: *const lapack_int,
sdim: *mut lapack_int,
alphar: *mut c_double,
alphai: *mut c_double,
beta: *mut c_double,
vsl: *mut c_double,
ldvsl: *const lapack_int,
vsr: *mut c_double,
ldvsr: *const lapack_int,
work: *mut c_double,
lwork: *const lapack_int,
bwork: *mut lapack_logical,
info: *mut lapack_int,
);
pub fn cgges_(
jobvsl: *const c_char,
jobvsr: *const c_char,
sort: *const c_char,
selctg: LAPACK_C_SELECT2,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
sdim: *mut lapack_int,
alpha: *mut lapack_complex_float,
beta: *mut lapack_complex_float,
vsl: *mut lapack_complex_float,
ldvsl: *const lapack_int,
vsr: *mut lapack_complex_float,
ldvsr: *const lapack_int,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
rwork: *mut c_float,
bwork: *mut lapack_logical,
info: *mut lapack_int,
);
pub fn zgges_(
jobvsl: *const c_char,
jobvsr: *const c_char,
sort: *const c_char,
selctg: LAPACK_Z_SELECT2,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
sdim: *mut lapack_int,
alpha: *mut lapack_complex_double,
beta: *mut lapack_complex_double,
vsl: *mut lapack_complex_double,
ldvsl: *const lapack_int,
vsr: *mut lapack_complex_double,
ldvsr: *const lapack_int,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
rwork: *mut c_double,
bwork: *mut lapack_logical,
info: *mut lapack_int,
);
pub fn sgges3_(
jobvsl: *const c_char,
jobvsr: *const c_char,
sort: *const c_char,
selctg: LAPACK_S_SELECT3,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
b: *mut c_float,
ldb: *const lapack_int,
sdim: *mut lapack_int,
alphar: *mut c_float,
alphai: *mut c_float,
beta: *mut c_float,
vsl: *mut c_float,
ldvsl: *const lapack_int,
vsr: *mut c_float,
ldvsr: *const lapack_int,
work: *mut c_float,
lwork: *const lapack_int,
bwork: *mut lapack_logical,
info: *mut lapack_int,
);
pub fn dgges3_(
jobvsl: *const c_char,
jobvsr: *const c_char,
sort: *const c_char,
selctg: LAPACK_D_SELECT3,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
b: *mut c_double,
ldb: *const lapack_int,
sdim: *mut lapack_int,
alphar: *mut c_double,
alphai: *mut c_double,
beta: *mut c_double,
vsl: *mut c_double,
ldvsl: *const lapack_int,
vsr: *mut c_double,
ldvsr: *const lapack_int,
work: *mut c_double,
lwork: *const lapack_int,
bwork: *mut lapack_logical,
info: *mut lapack_int,
);
pub fn cgges3_(
jobvsl: *const c_char,
jobvsr: *const c_char,
sort: *const c_char,
selctg: LAPACK_C_SELECT2,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
sdim: *mut lapack_int,
alpha: *mut lapack_complex_float,
beta: *mut lapack_complex_float,
vsl: *mut lapack_complex_float,
ldvsl: *const lapack_int,
vsr: *mut lapack_complex_float,
ldvsr: *const lapack_int,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
rwork: *mut c_float,
bwork: *mut lapack_logical,
info: *mut lapack_int,
);
pub fn zgges3_(
jobvsl: *const c_char,
jobvsr: *const c_char,
sort: *const c_char,
selctg: LAPACK_Z_SELECT2,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
sdim: *mut lapack_int,
alpha: *mut lapack_complex_double,
beta: *mut lapack_complex_double,
vsl: *mut lapack_complex_double,
ldvsl: *const lapack_int,
vsr: *mut lapack_complex_double,
ldvsr: *const lapack_int,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
rwork: *mut c_double,
bwork: *mut lapack_logical,
info: *mut lapack_int,
);
pub fn sggesx_(
jobvsl: *const c_char,
jobvsr: *const c_char,
sort: *const c_char,
selctg: LAPACK_S_SELECT3,
sense: *const c_char,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
b: *mut c_float,
ldb: *const lapack_int,
sdim: *mut lapack_int,
alphar: *mut c_float,
alphai: *mut c_float,
beta: *mut c_float,
vsl: *mut c_float,
ldvsl: *const lapack_int,
vsr: *mut c_float,
ldvsr: *const lapack_int,
rconde: *mut c_float,
rcondv: *mut c_float,
work: *mut c_float,
lwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
bwork: *mut lapack_logical,
info: *mut lapack_int,
);
pub fn dggesx_(
jobvsl: *const c_char,
jobvsr: *const c_char,
sort: *const c_char,
selctg: LAPACK_D_SELECT3,
sense: *const c_char,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
b: *mut c_double,
ldb: *const lapack_int,
sdim: *mut lapack_int,
alphar: *mut c_double,
alphai: *mut c_double,
beta: *mut c_double,
vsl: *mut c_double,
ldvsl: *const lapack_int,
vsr: *mut c_double,
ldvsr: *const lapack_int,
rconde: *mut c_double,
rcondv: *mut c_double,
work: *mut c_double,
lwork: *const lapack_int,
iwork: *mut lapack_int,
liwork: *const lapack_int,
bwork: *mut lapack_logical,
info: *mut lapack_int,
);
pub fn cggesx_(
jobvsl: *const c_char,
jobvsr: *const c_char,
sort: *const c_char,
selctg: LAPACK_C_SELECT2,
sense: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
sdim: *mut lapack_int,
alpha: *mut lapack_complex_float,
beta: *mut lapack_complex_float,
vsl: *mut lapack_complex_float,
ldvsl: *const lapack_int,
vsr: *mut lapack_complex_float,
ldvsr: *const lapack_int,
rconde: *mut c_float,
rcondv: *mut c_float,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
rwork: *mut c_float,
iwork: *mut lapack_int,
liwork: *const lapack_int,
bwork: *mut lapack_logical,
info: *mut lapack_int,
);
pub fn zggesx_(
jobvsl: *const c_char,
jobvsr: *const c_char,
sort: *const c_char,
selctg: LAPACK_Z_SELECT2,
sense: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
sdim: *mut lapack_int,
alpha: *mut lapack_complex_double,
beta: *mut lapack_complex_double,
vsl: *mut lapack_complex_double,
ldvsl: *const lapack_int,
vsr: *mut lapack_complex_double,
ldvsr: *const lapack_int,
rconde: *mut c_double,
rcondv: *mut c_double,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
rwork: *mut c_double,
iwork: *mut lapack_int,
liwork: *const lapack_int,
bwork: *mut lapack_logical,
info: *mut lapack_int,
);
pub fn sggev_(
jobvl: *const c_char,
jobvr: *const c_char,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
b: *mut c_float,
ldb: *const lapack_int,
alphar: *mut c_float,
alphai: *mut c_float,
beta: *mut c_float,
vl: *mut c_float,
ldvl: *const lapack_int,
vr: *mut c_float,
ldvr: *const lapack_int,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dggev_(
jobvl: *const c_char,
jobvr: *const c_char,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
b: *mut c_double,
ldb: *const lapack_int,
alphar: *mut c_double,
alphai: *mut c_double,
beta: *mut c_double,
vl: *mut c_double,
ldvl: *const lapack_int,
vr: *mut c_double,
ldvr: *const lapack_int,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn cggev_(
jobvl: *const c_char,
jobvr: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
alpha: *mut lapack_complex_float,
beta: *mut lapack_complex_float,
vl: *mut lapack_complex_float,
ldvl: *const lapack_int,
vr: *mut lapack_complex_float,
ldvr: *const lapack_int,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn zggev_(
jobvl: *const c_char,
jobvr: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
alpha: *mut lapack_complex_double,
beta: *mut lapack_complex_double,
vl: *mut lapack_complex_double,
ldvl: *const lapack_int,
vr: *mut lapack_complex_double,
ldvr: *const lapack_int,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn sggev3_(
jobvl: *const c_char,
jobvr: *const c_char,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
b: *mut c_float,
ldb: *const lapack_int,
alphar: *mut c_float,
alphai: *mut c_float,
beta: *mut c_float,
vl: *mut c_float,
ldvl: *const lapack_int,
vr: *mut c_float,
ldvr: *const lapack_int,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dggev3_(
jobvl: *const c_char,
jobvr: *const c_char,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
b: *mut c_double,
ldb: *const lapack_int,
alphar: *mut c_double,
alphai: *mut c_double,
beta: *mut c_double,
vl: *mut c_double,
ldvl: *const lapack_int,
vr: *mut c_double,
ldvr: *const lapack_int,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn cggev3_(
jobvl: *const c_char,
jobvr: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
alpha: *mut lapack_complex_float,
beta: *mut lapack_complex_float,
vl: *mut lapack_complex_float,
ldvl: *const lapack_int,
vr: *mut lapack_complex_float,
ldvr: *const lapack_int,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
rwork: *mut c_float,
info: *mut lapack_int,
);
pub fn zggev3_(
jobvl: *const c_char,
jobvr: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
alpha: *mut lapack_complex_double,
beta: *mut lapack_complex_double,
vl: *mut lapack_complex_double,
ldvl: *const lapack_int,
vr: *mut lapack_complex_double,
ldvr: *const lapack_int,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
rwork: *mut c_double,
info: *mut lapack_int,
);
pub fn sggevx_(
balanc: *const c_char,
jobvl: *const c_char,
jobvr: *const c_char,
sense: *const c_char,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
b: *mut c_float,
ldb: *const lapack_int,
alphar: *mut c_float,
alphai: *mut c_float,
beta: *mut c_float,
vl: *mut c_float,
ldvl: *const lapack_int,
vr: *mut c_float,
ldvr: *const lapack_int,
ilo: *mut lapack_int,
ihi: *mut lapack_int,
lscale: *mut c_float,
rscale: *mut c_float,
abnrm: *mut c_float,
bbnrm: *mut c_float,
rconde: *mut c_float,
rcondv: *mut c_float,
work: *mut c_float,
lwork: *const lapack_int,
iwork: *mut lapack_int,
bwork: *mut lapack_logical,
info: *mut lapack_int,
);
pub fn dggevx_(
balanc: *const c_char,
jobvl: *const c_char,
jobvr: *const c_char,
sense: *const c_char,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
b: *mut c_double,
ldb: *const lapack_int,
alphar: *mut c_double,
alphai: *mut c_double,
beta: *mut c_double,
vl: *mut c_double,
ldvl: *const lapack_int,
vr: *mut c_double,
ldvr: *const lapack_int,
ilo: *mut lapack_int,
ihi: *mut lapack_int,
lscale: *mut c_double,
rscale: *mut c_double,
abnrm: *mut c_double,
bbnrm: *mut c_double,
rconde: *mut c_double,
rcondv: *mut c_double,
work: *mut c_double,
lwork: *const lapack_int,
iwork: *mut lapack_int,
bwork: *mut lapack_logical,
info: *mut lapack_int,
);
pub fn cggevx_(
balanc: *const c_char,
jobvl: *const c_char,
jobvr: *const c_char,
sense: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
alpha: *mut lapack_complex_float,
beta: *mut lapack_complex_float,
vl: *mut lapack_complex_float,
ldvl: *const lapack_int,
vr: *mut lapack_complex_float,
ldvr: *const lapack_int,
ilo: *mut lapack_int,
ihi: *mut lapack_int,
lscale: *mut c_float,
rscale: *mut c_float,
abnrm: *mut c_float,
bbnrm: *mut c_float,
rconde: *mut c_float,
rcondv: *mut c_float,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
rwork: *mut c_float,
iwork: *mut lapack_int,
bwork: *mut lapack_logical,
info: *mut lapack_int,
);
pub fn zggevx_(
balanc: *const c_char,
jobvl: *const c_char,
jobvr: *const c_char,
sense: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
alpha: *mut lapack_complex_double,
beta: *mut lapack_complex_double,
vl: *mut lapack_complex_double,
ldvl: *const lapack_int,
vr: *mut lapack_complex_double,
ldvr: *const lapack_int,
ilo: *mut lapack_int,
ihi: *mut lapack_int,
lscale: *mut c_double,
rscale: *mut c_double,
abnrm: *mut c_double,
bbnrm: *mut c_double,
rconde: *mut c_double,
rcondv: *mut c_double,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
rwork: *mut c_double,
iwork: *mut lapack_int,
bwork: *mut lapack_logical,
info: *mut lapack_int,
);
pub fn dsfrk_(
transr: *const c_char,
uplo: *const c_char,
trans: *const c_char,
n: *const lapack_int,
k: *const lapack_int,
alpha: *const c_double,
a: *const c_double,
lda: *const lapack_int,
beta: *const c_double,
c: *mut c_double,
);
pub fn ssfrk_(
transr: *const c_char,
uplo: *const c_char,
trans: *const c_char,
n: *const lapack_int,
k: *const lapack_int,
alpha: *const c_float,
a: *const c_float,
lda: *const lapack_int,
beta: *const c_float,
c: *mut c_float,
);
pub fn zhfrk_(
transr: *const c_char,
uplo: *const c_char,
trans: *const c_char,
n: *const lapack_int,
k: *const lapack_int,
alpha: *const c_double,
a: *const lapack_complex_double,
lda: *const lapack_int,
beta: *const c_double,
c: *mut lapack_complex_double,
);
pub fn chfrk_(
transr: *const c_char,
uplo: *const c_char,
trans: *const c_char,
n: *const lapack_int,
k: *const lapack_int,
alpha: *const c_float,
a: *const lapack_complex_float,
lda: *const lapack_int,
beta: *const c_float,
c: *mut lapack_complex_float,
);
pub fn dtfsm_(
transr: *const c_char,
side: *const c_char,
uplo: *const c_char,
trans: *const c_char,
diag: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
alpha: *const c_double,
a: *const c_double,
b: *mut c_double,
ldb: *const lapack_int,
);
pub fn stfsm_(
transr: *const c_char,
side: *const c_char,
uplo: *const c_char,
trans: *const c_char,
diag: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
alpha: *const c_float,
a: *const c_float,
b: *mut c_float,
ldb: *const lapack_int,
);
pub fn ztfsm_(
transr: *const c_char,
side: *const c_char,
uplo: *const c_char,
trans: *const c_char,
diag: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
alpha: *const lapack_complex_double,
a: *const lapack_complex_double,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
);
pub fn ctfsm_(
transr: *const c_char,
side: *const c_char,
uplo: *const c_char,
trans: *const c_char,
diag: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
alpha: *const lapack_complex_float,
a: *const lapack_complex_float,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
);
pub fn dtfttp_(
transr: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
arf: *const c_double,
ap: *mut c_double,
info: *mut lapack_int,
);
pub fn stfttp_(
transr: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
arf: *const c_float,
ap: *mut c_float,
info: *mut lapack_int,
);
pub fn ztfttp_(
transr: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
arf: *const lapack_complex_double,
ap: *mut lapack_complex_double,
info: *mut lapack_int,
);
pub fn ctfttp_(
transr: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
arf: *const lapack_complex_float,
ap: *mut lapack_complex_float,
info: *mut lapack_int,
);
pub fn dtfttr_(
transr: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
arf: *const c_double,
a: *mut c_double,
lda: *const lapack_int,
info: *mut lapack_int,
);
pub fn stfttr_(
transr: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
arf: *const c_float,
a: *mut c_float,
lda: *const lapack_int,
info: *mut lapack_int,
);
pub fn ztfttr_(
transr: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
arf: *const lapack_complex_double,
a: *mut lapack_complex_double,
lda: *const lapack_int,
info: *mut lapack_int,
);
pub fn ctfttr_(
transr: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
arf: *const lapack_complex_float,
a: *mut lapack_complex_float,
lda: *const lapack_int,
info: *mut lapack_int,
);
pub fn dtpttf_(
transr: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
ap: *const c_double,
arf: *mut c_double,
info: *mut lapack_int,
);
pub fn stpttf_(
transr: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
ap: *const c_float,
arf: *mut c_float,
info: *mut lapack_int,
);
pub fn ztpttf_(
transr: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
ap: *const lapack_complex_double,
arf: *mut lapack_complex_double,
info: *mut lapack_int,
);
pub fn ctpttf_(
transr: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
ap: *const lapack_complex_float,
arf: *mut lapack_complex_float,
info: *mut lapack_int,
);
pub fn dtpttr_(
uplo: *const c_char,
n: *const lapack_int,
ap: *const c_double,
a: *mut c_double,
lda: *const lapack_int,
info: *mut lapack_int,
);
pub fn stpttr_(
uplo: *const c_char,
n: *const lapack_int,
ap: *const c_float,
a: *mut c_float,
lda: *const lapack_int,
info: *mut lapack_int,
);
pub fn ztpttr_(
uplo: *const c_char,
n: *const lapack_int,
ap: *const lapack_complex_double,
a: *mut lapack_complex_double,
lda: *const lapack_int,
info: *mut lapack_int,
);
pub fn ctpttr_(
uplo: *const c_char,
n: *const lapack_int,
ap: *const lapack_complex_float,
a: *mut lapack_complex_float,
lda: *const lapack_int,
info: *mut lapack_int,
);
pub fn dtrttf_(
transr: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
a: *const c_double,
lda: *const lapack_int,
arf: *mut c_double,
info: *mut lapack_int,
);
pub fn strttf_(
transr: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
a: *const c_float,
lda: *const lapack_int,
arf: *mut c_float,
info: *mut lapack_int,
);
pub fn ztrttf_(
transr: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
arf: *mut lapack_complex_double,
info: *mut lapack_int,
);
pub fn ctrttf_(
transr: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
arf: *mut lapack_complex_float,
info: *mut lapack_int,
);
pub fn dtrttp_(
uplo: *const c_char,
n: *const lapack_int,
a: *const c_double,
lda: *const lapack_int,
ap: *mut c_double,
info: *mut lapack_int,
);
pub fn strttp_(
uplo: *const c_char,
n: *const lapack_int,
a: *const c_float,
lda: *const lapack_int,
ap: *mut c_float,
info: *mut lapack_int,
);
pub fn ztrttp_(
uplo: *const c_char,
n: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
ap: *mut lapack_complex_double,
info: *mut lapack_int,
);
pub fn ctrttp_(
uplo: *const c_char,
n: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
ap: *mut lapack_complex_float,
info: *mut lapack_int,
);
pub fn sgeqrfp_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
tau: *mut c_float,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dgeqrfp_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
tau: *mut c_double,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn cgeqrfp_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
tau: *mut lapack_complex_float,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zgeqrfp_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
tau: *mut lapack_complex_double,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn clacgv_(n: *const lapack_int, x: *mut lapack_complex_float, incx: *const lapack_int);
pub fn zlacgv_(n: *const lapack_int, x: *mut lapack_complex_double, incx: *const lapack_int);
pub fn slarnv_(
idist: *const lapack_int,
iseed: *mut lapack_int,
n: *const lapack_int,
x: *mut c_float,
);
pub fn dlarnv_(
idist: *const lapack_int,
iseed: *mut lapack_int,
n: *const lapack_int,
x: *mut c_double,
);
pub fn clarnv_(
idist: *const lapack_int,
iseed: *mut lapack_int,
n: *const lapack_int,
x: *mut lapack_complex_float,
);
pub fn zlarnv_(
idist: *const lapack_int,
iseed: *mut lapack_int,
n: *const lapack_int,
x: *mut lapack_complex_double,
);
pub fn sgeqr2_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
tau: *mut c_float,
work: *mut c_float,
info: *mut lapack_int,
);
pub fn dgeqr2_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
tau: *mut c_double,
work: *mut c_double,
info: *mut lapack_int,
);
pub fn cgeqr2_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
tau: *mut lapack_complex_float,
work: *mut lapack_complex_float,
info: *mut lapack_int,
);
pub fn zgeqr2_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
tau: *mut lapack_complex_double,
work: *mut lapack_complex_double,
info: *mut lapack_int,
);
pub fn slacn2_(
n: *const lapack_int,
v: *mut c_float,
x: *mut c_float,
isgn: *mut lapack_int,
est: *mut c_float,
kase: *mut lapack_int,
isave: *mut lapack_int,
);
pub fn dlacn2_(
n: *const lapack_int,
v: *mut c_double,
x: *mut c_double,
isgn: *mut lapack_int,
est: *mut c_double,
kase: *mut lapack_int,
isave: *mut lapack_int,
);
pub fn clacn2_(
n: *const lapack_int,
v: *mut lapack_complex_float,
x: *mut lapack_complex_float,
est: *mut c_float,
kase: *mut lapack_int,
isave: *mut lapack_int,
);
pub fn zlacn2_(
n: *const lapack_int,
v: *mut lapack_complex_double,
x: *mut lapack_complex_double,
est: *mut c_double,
kase: *mut lapack_int,
isave: *mut lapack_int,
);
pub fn slacpy_(
uplo: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
a: *const c_float,
lda: *const lapack_int,
b: *mut c_float,
ldb: *const lapack_int,
);
pub fn dlacpy_(
uplo: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
a: *const c_double,
lda: *const lapack_int,
b: *mut c_double,
ldb: *const lapack_int,
);
pub fn clacpy_(
uplo: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
);
pub fn zlacpy_(
uplo: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
);
pub fn clacp2_(
uplo: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
a: *const c_float,
lda: *const lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
);
pub fn zlacp2_(
uplo: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
a: *const c_double,
lda: *const lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
);
pub fn sgetf2_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
ipiv: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dgetf2_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
ipiv: *mut lapack_int,
info: *mut lapack_int,
);
pub fn cgetf2_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
ipiv: *mut lapack_int,
info: *mut lapack_int,
);
pub fn zgetf2_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
ipiv: *mut lapack_int,
info: *mut lapack_int,
);
pub fn slaswp_(
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
k1: *const lapack_int,
k2: *const lapack_int,
ipiv: *const lapack_int,
incx: *const lapack_int,
);
pub fn dlaswp_(
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
k1: *const lapack_int,
k2: *const lapack_int,
ipiv: *const lapack_int,
incx: *const lapack_int,
);
pub fn claswp_(
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
k1: *const lapack_int,
k2: *const lapack_int,
ipiv: *const lapack_int,
incx: *const lapack_int,
);
pub fn zlaswp_(
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
k1: *const lapack_int,
k2: *const lapack_int,
ipiv: *const lapack_int,
incx: *const lapack_int,
);
pub fn slange_(
norm: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
a: *const c_float,
lda: *const lapack_int,
work: *mut c_float,
) -> c_float;
pub fn dlange_(
norm: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
a: *const c_double,
lda: *const lapack_int,
work: *mut c_double,
) -> c_double;
pub fn clange_(
norm: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
work: *mut c_float,
) -> c_float;
pub fn zlange_(
norm: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
work: *mut c_double,
) -> c_double;
pub fn clanhe_(
norm: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
work: *mut c_float,
) -> c_float;
pub fn zlanhe_(
norm: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
work: *mut c_double,
) -> c_double;
pub fn slansy_(
norm: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
a: *const c_float,
lda: *const lapack_int,
work: *mut c_float,
) -> c_float;
pub fn dlansy_(
norm: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
a: *const c_double,
lda: *const lapack_int,
work: *mut c_double,
) -> c_double;
pub fn clansy_(
norm: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
work: *mut c_float,
) -> c_float;
pub fn zlansy_(
norm: *const c_char,
uplo: *const c_char,
n: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
work: *mut c_double,
) -> c_double;
pub fn slantr_(
norm: *const c_char,
uplo: *const c_char,
diag: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
a: *const c_float,
lda: *const lapack_int,
work: *mut c_float,
) -> c_float;
pub fn dlantr_(
norm: *const c_char,
uplo: *const c_char,
diag: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
a: *const c_double,
lda: *const lapack_int,
work: *mut c_double,
) -> c_double;
pub fn clantr_(
norm: *const c_char,
uplo: *const c_char,
diag: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
work: *mut c_float,
) -> c_float;
pub fn zlantr_(
norm: *const c_char,
uplo: *const c_char,
diag: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
work: *mut c_double,
) -> c_double;
pub fn slamch_(cmach: *const c_char) -> c_float;
pub fn dlamch_(cmach: *const c_char) -> c_double;
pub fn sgelq2_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
tau: *mut c_float,
work: *mut c_float,
info: *mut lapack_int,
);
pub fn dgelq2_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
tau: *mut c_double,
work: *mut c_double,
info: *mut lapack_int,
);
pub fn cgelq2_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
tau: *mut lapack_complex_float,
work: *mut lapack_complex_float,
info: *mut lapack_int,
);
pub fn zgelq2_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
tau: *mut lapack_complex_double,
work: *mut lapack_complex_double,
info: *mut lapack_int,
);
pub fn slarfb_(
side: *const c_char,
trans: *const c_char,
direct: *const c_char,
storev: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
v: *const c_float,
ldv: *const lapack_int,
t: *const c_float,
ldt: *const lapack_int,
c: *mut c_float,
ldc: *const lapack_int,
work: *mut c_float,
ldwork: *const lapack_int,
);
pub fn dlarfb_(
side: *const c_char,
trans: *const c_char,
direct: *const c_char,
storev: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
v: *const c_double,
ldv: *const lapack_int,
t: *const c_double,
ldt: *const lapack_int,
c: *mut c_double,
ldc: *const lapack_int,
work: *mut c_double,
ldwork: *const lapack_int,
);
pub fn clarfb_(
side: *const c_char,
trans: *const c_char,
direct: *const c_char,
storev: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
v: *const lapack_complex_float,
ldv: *const lapack_int,
t: *const lapack_complex_float,
ldt: *const lapack_int,
c: *mut lapack_complex_float,
ldc: *const lapack_int,
work: *mut lapack_complex_float,
ldwork: *const lapack_int,
);
pub fn zlarfb_(
side: *const c_char,
trans: *const c_char,
direct: *const c_char,
storev: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
v: *const lapack_complex_double,
ldv: *const lapack_int,
t: *const lapack_complex_double,
ldt: *const lapack_int,
c: *mut lapack_complex_double,
ldc: *const lapack_int,
work: *mut lapack_complex_double,
ldwork: *const lapack_int,
);
pub fn slarfg_(
n: *const lapack_int,
alpha: *mut c_float,
x: *mut c_float,
incx: *const lapack_int,
tau: *mut c_float,
);
pub fn dlarfg_(
n: *const lapack_int,
alpha: *mut c_double,
x: *mut c_double,
incx: *const lapack_int,
tau: *mut c_double,
);
pub fn clarfg_(
n: *const lapack_int,
alpha: *mut lapack_complex_float,
x: *mut lapack_complex_float,
incx: *const lapack_int,
tau: *mut lapack_complex_float,
);
pub fn zlarfg_(
n: *const lapack_int,
alpha: *mut lapack_complex_double,
x: *mut lapack_complex_double,
incx: *const lapack_int,
tau: *mut lapack_complex_double,
);
pub fn slarft_(
direct: *const c_char,
storev: *const c_char,
n: *const lapack_int,
k: *const lapack_int,
v: *const c_float,
ldv: *const lapack_int,
tau: *const c_float,
t: *mut c_float,
ldt: *const lapack_int,
);
pub fn dlarft_(
direct: *const c_char,
storev: *const c_char,
n: *const lapack_int,
k: *const lapack_int,
v: *const c_double,
ldv: *const lapack_int,
tau: *const c_double,
t: *mut c_double,
ldt: *const lapack_int,
);
pub fn clarft_(
direct: *const c_char,
storev: *const c_char,
n: *const lapack_int,
k: *const lapack_int,
v: *const lapack_complex_float,
ldv: *const lapack_int,
tau: *const lapack_complex_float,
t: *mut lapack_complex_float,
ldt: *const lapack_int,
);
pub fn zlarft_(
direct: *const c_char,
storev: *const c_char,
n: *const lapack_int,
k: *const lapack_int,
v: *const lapack_complex_double,
ldv: *const lapack_int,
tau: *const lapack_complex_double,
t: *mut lapack_complex_double,
ldt: *const lapack_int,
);
pub fn slarfx_(
side: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
v: *const c_float,
tau: *const c_float,
c: *mut c_float,
ldc: *const lapack_int,
work: *mut c_float,
);
pub fn dlarfx_(
side: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
v: *const c_double,
tau: *const c_double,
c: *mut c_double,
ldc: *const lapack_int,
work: *mut c_double,
);
pub fn clarfx_(
side: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
v: *const lapack_complex_float,
tau: *const lapack_complex_float,
c: *mut lapack_complex_float,
ldc: *const lapack_int,
work: *mut lapack_complex_float,
);
pub fn zlarfx_(
side: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
v: *const lapack_complex_double,
tau: *const lapack_complex_double,
c: *mut lapack_complex_double,
ldc: *const lapack_int,
work: *mut lapack_complex_double,
);
pub fn slatms_(
m: *const lapack_int,
n: *const lapack_int,
dist: *const c_char,
iseed: *mut lapack_int,
sym: *const c_char,
d: *mut c_float,
mode: *const lapack_int,
cond: *const c_float,
dmax: *const c_float,
kl: *const lapack_int,
ku: *const lapack_int,
pack: *const c_char,
a: *mut c_float,
lda: *const lapack_int,
work: *mut c_float,
info: *mut lapack_int,
);
pub fn dlatms_(
m: *const lapack_int,
n: *const lapack_int,
dist: *const c_char,
iseed: *mut lapack_int,
sym: *const c_char,
d: *mut c_double,
mode: *const lapack_int,
cond: *const c_double,
dmax: *const c_double,
kl: *const lapack_int,
ku: *const lapack_int,
pack: *const c_char,
a: *mut c_double,
lda: *const lapack_int,
work: *mut c_double,
info: *mut lapack_int,
);
pub fn clatms_(
m: *const lapack_int,
n: *const lapack_int,
dist: *const c_char,
iseed: *mut lapack_int,
sym: *const c_char,
d: *mut c_float,
mode: *const lapack_int,
cond: *const c_float,
dmax: *const c_float,
kl: *const lapack_int,
ku: *const lapack_int,
pack: *const c_char,
a: *mut lapack_complex_float,
lda: *const lapack_int,
work: *mut lapack_complex_float,
info: *mut lapack_int,
);
pub fn zlatms_(
m: *const lapack_int,
n: *const lapack_int,
dist: *const c_char,
iseed: *mut lapack_int,
sym: *const c_char,
d: *mut c_double,
mode: *const lapack_int,
cond: *const c_double,
dmax: *const c_double,
kl: *const lapack_int,
ku: *const lapack_int,
pack: *const c_char,
a: *mut lapack_complex_double,
lda: *const lapack_int,
work: *mut lapack_complex_double,
info: *mut lapack_int,
);
pub fn slag2d_(
m: *const lapack_int,
n: *const lapack_int,
sa: *const c_float,
ldsa: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
info: *mut lapack_int,
);
pub fn dlag2s_(
m: *const lapack_int,
n: *const lapack_int,
a: *const c_double,
lda: *const lapack_int,
sa: *mut c_float,
ldsa: *const lapack_int,
info: *mut lapack_int,
);
pub fn clag2z_(
m: *const lapack_int,
n: *const lapack_int,
sa: *const lapack_complex_float,
ldsa: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
info: *mut lapack_int,
);
pub fn zlag2c_(
m: *const lapack_int,
n: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
sa: *mut lapack_complex_float,
ldsa: *const lapack_int,
info: *mut lapack_int,
);
pub fn slauum_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
info: *mut lapack_int,
);
pub fn dlauum_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
info: *mut lapack_int,
);
pub fn clauum_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
info: *mut lapack_int,
);
pub fn zlauum_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
info: *mut lapack_int,
);
pub fn slagge_(
m: *const lapack_int,
n: *const lapack_int,
kl: *const lapack_int,
ku: *const lapack_int,
d: *const c_float,
a: *mut c_float,
lda: *const lapack_int,
iseed: *mut lapack_int,
work: *mut c_float,
info: *mut lapack_int,
);
pub fn dlagge_(
m: *const lapack_int,
n: *const lapack_int,
kl: *const lapack_int,
ku: *const lapack_int,
d: *const c_double,
a: *mut c_double,
lda: *const lapack_int,
iseed: *mut lapack_int,
work: *mut c_double,
info: *mut lapack_int,
);
pub fn clagge_(
m: *const lapack_int,
n: *const lapack_int,
kl: *const lapack_int,
ku: *const lapack_int,
d: *const c_float,
a: *mut lapack_complex_float,
lda: *const lapack_int,
iseed: *mut lapack_int,
work: *mut lapack_complex_float,
info: *mut lapack_int,
);
pub fn zlagge_(
m: *const lapack_int,
n: *const lapack_int,
kl: *const lapack_int,
ku: *const lapack_int,
d: *const c_double,
a: *mut lapack_complex_double,
lda: *const lapack_int,
iseed: *mut lapack_int,
work: *mut lapack_complex_double,
info: *mut lapack_int,
);
pub fn slascl_(
_type: *const c_char,
kl: *const lapack_int,
ku: *const lapack_int,
cfrom: *const c_float,
cto: *const c_float,
m: *const lapack_int,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
info: *mut lapack_int,
);
pub fn dlascl_(
_type: *const c_char,
kl: *const lapack_int,
ku: *const lapack_int,
cfrom: *const c_double,
cto: *const c_double,
m: *const lapack_int,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
info: *mut lapack_int,
);
pub fn clascl_(
_type: *const c_char,
kl: *const lapack_int,
ku: *const lapack_int,
cfrom: *const c_float,
cto: *const c_float,
m: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
info: *mut lapack_int,
);
pub fn zlascl_(
_type: *const c_char,
kl: *const lapack_int,
ku: *const lapack_int,
cfrom: *const c_double,
cto: *const c_double,
m: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
info: *mut lapack_int,
);
pub fn slaset_(
uplo: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
alpha: *const c_float,
beta: *const c_float,
a: *mut c_float,
lda: *const lapack_int,
);
pub fn dlaset_(
uplo: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
alpha: *const c_double,
beta: *const c_double,
a: *mut c_double,
lda: *const lapack_int,
);
pub fn claset_(
uplo: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
alpha: *const lapack_complex_float,
beta: *const lapack_complex_float,
a: *mut lapack_complex_float,
lda: *const lapack_int,
);
pub fn zlaset_(
uplo: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
alpha: *const lapack_complex_double,
beta: *const lapack_complex_double,
a: *mut lapack_complex_double,
lda: *const lapack_int,
);
pub fn slasrt_(id: *const c_char, n: *const lapack_int, d: *mut c_float, info: *mut lapack_int);
pub fn dlasrt_(
id: *const c_char,
n: *const lapack_int,
d: *mut c_double,
info: *mut lapack_int,
);
pub fn claghe_(
n: *const lapack_int,
k: *const lapack_int,
d: *const c_float,
a: *mut lapack_complex_float,
lda: *const lapack_int,
iseed: *mut lapack_int,
work: *mut lapack_complex_float,
info: *mut lapack_int,
);
pub fn zlaghe_(
n: *const lapack_int,
k: *const lapack_int,
d: *const c_double,
a: *mut lapack_complex_double,
lda: *const lapack_int,
iseed: *mut lapack_int,
work: *mut lapack_complex_double,
info: *mut lapack_int,
);
pub fn slagsy_(
n: *const lapack_int,
k: *const lapack_int,
d: *const c_float,
a: *mut c_float,
lda: *const lapack_int,
iseed: *mut lapack_int,
work: *mut c_float,
info: *mut lapack_int,
);
pub fn dlagsy_(
n: *const lapack_int,
k: *const lapack_int,
d: *const c_double,
a: *mut c_double,
lda: *const lapack_int,
iseed: *mut lapack_int,
work: *mut c_double,
info: *mut lapack_int,
);
pub fn clagsy_(
n: *const lapack_int,
k: *const lapack_int,
d: *const c_float,
a: *mut lapack_complex_float,
lda: *const lapack_int,
iseed: *mut lapack_int,
work: *mut lapack_complex_float,
info: *mut lapack_int,
);
pub fn zlagsy_(
n: *const lapack_int,
k: *const lapack_int,
d: *const c_double,
a: *mut lapack_complex_double,
lda: *const lapack_int,
iseed: *mut lapack_int,
work: *mut lapack_complex_double,
info: *mut lapack_int,
);
pub fn slapmr_(
forwrd: *const lapack_logical,
m: *const lapack_int,
n: *const lapack_int,
x: *mut c_float,
ldx: *const lapack_int,
k: *mut lapack_int,
);
pub fn dlapmr_(
forwrd: *const lapack_logical,
m: *const lapack_int,
n: *const lapack_int,
x: *mut c_double,
ldx: *const lapack_int,
k: *mut lapack_int,
);
pub fn clapmr_(
forwrd: *const lapack_logical,
m: *const lapack_int,
n: *const lapack_int,
x: *mut lapack_complex_float,
ldx: *const lapack_int,
k: *mut lapack_int,
);
pub fn zlapmr_(
forwrd: *const lapack_logical,
m: *const lapack_int,
n: *const lapack_int,
x: *mut lapack_complex_double,
ldx: *const lapack_int,
k: *mut lapack_int,
);
pub fn slapmt_(
forwrd: *const lapack_logical,
m: *const lapack_int,
n: *const lapack_int,
x: *mut c_float,
ldx: *const lapack_int,
k: *mut lapack_int,
);
pub fn dlapmt_(
forwrd: *const lapack_logical,
m: *const lapack_int,
n: *const lapack_int,
x: *mut c_double,
ldx: *const lapack_int,
k: *mut lapack_int,
);
pub fn clapmt_(
forwrd: *const lapack_logical,
m: *const lapack_int,
n: *const lapack_int,
x: *mut lapack_complex_float,
ldx: *const lapack_int,
k: *mut lapack_int,
);
pub fn zlapmt_(
forwrd: *const lapack_logical,
m: *const lapack_int,
n: *const lapack_int,
x: *mut lapack_complex_double,
ldx: *const lapack_int,
k: *mut lapack_int,
);
pub fn slapy2_(x: *const c_float, y: *const c_float) -> c_float;
pub fn dlapy2_(x: *const c_double, y: *const c_double) -> c_double;
pub fn slapy3_(x: *const c_float, y: *const c_float, z: *const c_float) -> c_float;
pub fn dlapy3_(x: *const c_double, y: *const c_double, z: *const c_double) -> c_double;
pub fn slartgp_(
f: *const c_float,
g: *const c_float,
cs: *mut c_float,
sn: *mut c_float,
r: *mut c_float,
);
pub fn dlartgp_(
f: *const c_double,
g: *const c_double,
cs: *mut c_double,
sn: *mut c_double,
r: *mut c_double,
);
pub fn slartgs_(
x: *const c_float,
y: *const c_float,
sigma: *const c_float,
cs: *mut c_float,
sn: *mut c_float,
);
pub fn dlartgs_(
x: *const c_double,
y: *const c_double,
sigma: *const c_double,
cs: *mut c_double,
sn: *mut c_double,
);
// Version 3.3.0
pub fn cbbcsd_(
jobu1: *const c_char,
jobu2: *const c_char,
jobv1t: *const c_char,
jobv2t: *const c_char,
trans: *const c_char,
m: *const lapack_int,
p: *const lapack_int,
q: *const lapack_int,
theta: *mut c_float,
phi: *mut c_float,
u1: *mut lapack_complex_float,
ldu1: *const lapack_int,
u2: *mut lapack_complex_float,
ldu2: *const lapack_int,
v1t: *mut lapack_complex_float,
ldv1t: *const lapack_int,
v2t: *mut lapack_complex_float,
ldv2t: *const lapack_int,
b11d: *mut c_float,
b11e: *mut c_float,
b12d: *mut c_float,
b12e: *mut c_float,
b21d: *mut c_float,
b21e: *mut c_float,
b22d: *mut c_float,
b22e: *mut c_float,
rwork: *mut c_float,
lrwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn cheswapr_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_float,
i1: *const lapack_int,
i2: *const lapack_int,
);
pub fn chetri2_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
ipiv: *const lapack_int,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn chetri2x_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
ipiv: *const lapack_int,
work: *mut lapack_complex_float,
nb: *const lapack_int,
info: *mut lapack_int,
);
pub fn chetrs2_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
ipiv: *const lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
work: *mut lapack_complex_float,
info: *mut lapack_int,
);
pub fn csyconv_(
uplo: *const c_char,
way: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
ipiv: *const lapack_int,
work: *mut lapack_complex_float,
info: *mut lapack_int,
);
pub fn csyswapr_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_float,
i1: *const lapack_int,
i2: *const lapack_int,
);
pub fn csytri2_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
ipiv: *const lapack_int,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn csytri2x_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
ipiv: *const lapack_int,
work: *mut lapack_complex_float,
nb: *const lapack_int,
info: *mut lapack_int,
);
pub fn csytrs2_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
ipiv: *const lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
work: *mut lapack_complex_float,
info: *mut lapack_int,
);
pub fn cunbdb_(
trans: *const c_char,
signs: *const c_char,
m: *const lapack_int,
p: *const lapack_int,
q: *const lapack_int,
x11: *mut lapack_complex_float,
ldx11: *const lapack_int,
x12: *mut lapack_complex_float,
ldx12: *const lapack_int,
x21: *mut lapack_complex_float,
ldx21: *const lapack_int,
x22: *mut lapack_complex_float,
ldx22: *const lapack_int,
theta: *mut c_float,
phi: *mut c_float,
taup1: *mut lapack_complex_float,
taup2: *mut lapack_complex_float,
tauq1: *mut lapack_complex_float,
tauq2: *mut lapack_complex_float,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn cuncsd_(
jobu1: *const c_char,
jobu2: *const c_char,
jobv1t: *const c_char,
jobv2t: *const c_char,
trans: *const c_char,
signs: *const c_char,
m: *const lapack_int,
p: *const lapack_int,
q: *const lapack_int,
x11: *mut lapack_complex_float,
ldx11: *const lapack_int,
x12: *mut lapack_complex_float,
ldx12: *const lapack_int,
x21: *mut lapack_complex_float,
ldx21: *const lapack_int,
x22: *mut lapack_complex_float,
ldx22: *const lapack_int,
theta: *mut c_float,
u1: *mut lapack_complex_float,
ldu1: *const lapack_int,
u2: *mut lapack_complex_float,
ldu2: *const lapack_int,
v1t: *mut lapack_complex_float,
ldv1t: *const lapack_int,
v2t: *mut lapack_complex_float,
ldv2t: *const lapack_int,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
rwork: *mut c_float,
lrwork: *const lapack_int,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn cuncsd2by1_(
jobu1: *const c_char,
jobu2: *const c_char,
jobv1t: *const c_char,
m: *const lapack_int,
p: *const lapack_int,
q: *const lapack_int,
x11: *mut lapack_complex_float,
ldx11: *const lapack_int,
x21: *mut lapack_complex_float,
ldx21: *const lapack_int,
theta: *mut lapack_complex_float,
u1: *mut lapack_complex_float,
ldu1: *const lapack_int,
u2: *mut lapack_complex_float,
ldu2: *const lapack_int,
v1t: *mut lapack_complex_float,
ldv1t: *const lapack_int,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
rwork: *mut c_float,
lrwork: *const lapack_int,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dbbcsd_(
jobu1: *const c_char,
jobu2: *const c_char,
jobv1t: *const c_char,
jobv2t: *const c_char,
trans: *const c_char,
m: *const lapack_int,
p: *const lapack_int,
q: *const lapack_int,
theta: *mut c_double,
phi: *mut c_double,
u1: *mut c_double,
ldu1: *const lapack_int,
u2: *mut c_double,
ldu2: *const lapack_int,
v1t: *mut c_double,
ldv1t: *const lapack_int,
v2t: *mut c_double,
ldv2t: *const lapack_int,
b11d: *mut c_double,
b11e: *mut c_double,
b12d: *mut c_double,
b12e: *mut c_double,
b21d: *mut c_double,
b21e: *mut c_double,
b22d: *mut c_double,
b22e: *mut c_double,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dorbdb_(
trans: *const c_char,
signs: *const c_char,
m: *const lapack_int,
p: *const lapack_int,
q: *const lapack_int,
x11: *mut c_double,
ldx11: *const lapack_int,
x12: *mut c_double,
ldx12: *const lapack_int,
x21: *mut c_double,
ldx21: *const lapack_int,
x22: *mut c_double,
ldx22: *const lapack_int,
theta: *mut c_double,
phi: *mut c_double,
taup1: *mut c_double,
taup2: *mut c_double,
tauq1: *mut c_double,
tauq2: *mut c_double,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dorcsd_(
jobu1: *const c_char,
jobu2: *const c_char,
jobv1t: *const c_char,
jobv2t: *const c_char,
trans: *const c_char,
signs: *const c_char,
m: *const lapack_int,
p: *const lapack_int,
q: *const lapack_int,
x11: *mut c_double,
ldx11: *const lapack_int,
x12: *mut c_double,
ldx12: *const lapack_int,
x21: *mut c_double,
ldx21: *const lapack_int,
x22: *mut c_double,
ldx22: *const lapack_int,
theta: *mut c_double,
u1: *mut c_double,
ldu1: *const lapack_int,
u2: *mut c_double,
ldu2: *const lapack_int,
v1t: *mut c_double,
ldv1t: *const lapack_int,
v2t: *mut c_double,
ldv2t: *const lapack_int,
work: *mut c_double,
lwork: *const lapack_int,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dorcsd2by1_(
jobu1: *const c_char,
jobu2: *const c_char,
jobv1t: *const c_char,
m: *const lapack_int,
p: *const lapack_int,
q: *const lapack_int,
x11: *mut c_double,
ldx11: *const lapack_int,
x21: *mut c_double,
ldx21: *const lapack_int,
theta: *mut c_double,
u1: *mut c_double,
ldu1: *const lapack_int,
u2: *mut c_double,
ldu2: *const lapack_int,
v1t: *mut c_double,
ldv1t: *const lapack_int,
work: *mut c_double,
lwork: *const lapack_int,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn dsyconv_(
uplo: *const c_char,
way: *const c_char,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
ipiv: *const lapack_int,
work: *mut c_double,
info: *mut lapack_int,
);
pub fn dsyswapr_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut c_double,
i1: *const lapack_int,
i2: *const lapack_int,
);
pub fn dsytri2_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
ipiv: *const lapack_int,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dsytri2x_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
ipiv: *const lapack_int,
work: *mut c_double,
nb: *const lapack_int,
info: *mut lapack_int,
);
pub fn dsytrs2_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const c_double,
lda: *const lapack_int,
ipiv: *const lapack_int,
b: *mut c_double,
ldb: *const lapack_int,
work: *mut c_double,
info: *mut lapack_int,
);
pub fn sbbcsd_(
jobu1: *const c_char,
jobu2: *const c_char,
jobv1t: *const c_char,
jobv2t: *const c_char,
trans: *const c_char,
m: *const lapack_int,
p: *const lapack_int,
q: *const lapack_int,
theta: *mut c_float,
phi: *mut c_float,
u1: *mut c_float,
ldu1: *const lapack_int,
u2: *mut c_float,
ldu2: *const lapack_int,
v1t: *mut c_float,
ldv1t: *const lapack_int,
v2t: *mut c_float,
ldv2t: *const lapack_int,
b11d: *mut c_float,
b11e: *mut c_float,
b12d: *mut c_float,
b12e: *mut c_float,
b21d: *mut c_float,
b21e: *mut c_float,
b22d: *mut c_float,
b22e: *mut c_float,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn sorbdb_(
trans: *const c_char,
signs: *const c_char,
m: *const lapack_int,
p: *const lapack_int,
q: *const lapack_int,
x11: *mut c_float,
ldx11: *const lapack_int,
x12: *mut c_float,
ldx12: *const lapack_int,
x21: *mut c_float,
ldx21: *const lapack_int,
x22: *mut c_float,
ldx22: *const lapack_int,
theta: *mut c_float,
phi: *mut c_float,
taup1: *mut c_float,
taup2: *mut c_float,
tauq1: *mut c_float,
tauq2: *mut c_float,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn sorcsd_(
jobu1: *const c_char,
jobu2: *const c_char,
jobv1t: *const c_char,
jobv2t: *const c_char,
trans: *const c_char,
signs: *const c_char,
m: *const lapack_int,
p: *const lapack_int,
q: *const lapack_int,
x11: *mut c_float,
ldx11: *const lapack_int,
x12: *mut c_float,
ldx12: *const lapack_int,
x21: *mut c_float,
ldx21: *const lapack_int,
x22: *mut c_float,
ldx22: *const lapack_int,
theta: *mut c_float,
u1: *mut c_float,
ldu1: *const lapack_int,
u2: *mut c_float,
ldu2: *const lapack_int,
v1t: *mut c_float,
ldv1t: *const lapack_int,
v2t: *mut c_float,
ldv2t: *const lapack_int,
work: *mut c_float,
lwork: *const lapack_int,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn sorcsd2by1_(
jobu1: *const c_char,
jobu2: *const c_char,
jobv1t: *const c_char,
m: *const lapack_int,
p: *const lapack_int,
q: *const lapack_int,
x11: *mut c_float,
ldx11: *const lapack_int,
x21: *mut c_float,
ldx21: *const lapack_int,
theta: *mut c_float,
u1: *mut c_float,
ldu1: *const lapack_int,
u2: *mut c_float,
ldu2: *const lapack_int,
v1t: *mut c_float,
ldv1t: *const lapack_int,
work: *mut c_float,
lwork: *const lapack_int,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn ssyconv_(
uplo: *const c_char,
way: *const c_char,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
ipiv: *const lapack_int,
work: *mut c_float,
info: *mut lapack_int,
);
pub fn ssyswapr_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut c_float,
i1: *const lapack_int,
i2: *const lapack_int,
);
pub fn ssytri2_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
ipiv: *const lapack_int,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn ssytri2x_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
ipiv: *const lapack_int,
work: *mut c_float,
nb: *const lapack_int,
info: *mut lapack_int,
);
pub fn ssytrs2_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const c_float,
lda: *const lapack_int,
ipiv: *const lapack_int,
b: *mut c_float,
ldb: *const lapack_int,
work: *mut c_float,
info: *mut lapack_int,
);
pub fn zbbcsd_(
jobu1: *const c_char,
jobu2: *const c_char,
jobv1t: *const c_char,
jobv2t: *const c_char,
trans: *const c_char,
m: *const lapack_int,
p: *const lapack_int,
q: *const lapack_int,
theta: *mut c_double,
phi: *mut c_double,
u1: *mut lapack_complex_double,
ldu1: *const lapack_int,
u2: *mut lapack_complex_double,
ldu2: *const lapack_int,
v1t: *mut lapack_complex_double,
ldv1t: *const lapack_int,
v2t: *mut lapack_complex_double,
ldv2t: *const lapack_int,
b11d: *mut c_double,
b11e: *mut c_double,
b12d: *mut c_double,
b12e: *mut c_double,
b21d: *mut c_double,
b21e: *mut c_double,
b22d: *mut c_double,
b22e: *mut c_double,
rwork: *mut c_double,
lrwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zheswapr_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_double,
i1: *const lapack_int,
i2: *const lapack_int,
);
pub fn zhetri2_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
ipiv: *const lapack_int,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zhetri2x_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
ipiv: *const lapack_int,
work: *mut lapack_complex_double,
nb: *const lapack_int,
info: *mut lapack_int,
);
pub fn zhetrs2_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
ipiv: *const lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
work: *mut lapack_complex_double,
info: *mut lapack_int,
);
pub fn zsyconv_(
uplo: *const c_char,
way: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
ipiv: *const lapack_int,
work: *mut lapack_complex_double,
info: *mut lapack_int,
);
pub fn zsyswapr_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_double,
i1: *const lapack_int,
i2: *const lapack_int,
);
pub fn zsytri2_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
ipiv: *const lapack_int,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zsytri2x_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
ipiv: *const lapack_int,
work: *mut lapack_complex_double,
nb: *const lapack_int,
info: *mut lapack_int,
);
pub fn zsytrs2_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
ipiv: *const lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
work: *mut lapack_complex_double,
info: *mut lapack_int,
);
pub fn zunbdb_(
trans: *const c_char,
signs: *const c_char,
m: *const lapack_int,
p: *const lapack_int,
q: *const lapack_int,
x11: *mut lapack_complex_double,
ldx11: *const lapack_int,
x12: *mut lapack_complex_double,
ldx12: *const lapack_int,
x21: *mut lapack_complex_double,
ldx21: *const lapack_int,
x22: *mut lapack_complex_double,
ldx22: *const lapack_int,
theta: *mut c_double,
phi: *mut c_double,
taup1: *mut lapack_complex_double,
taup2: *mut lapack_complex_double,
tauq1: *mut lapack_complex_double,
tauq2: *mut lapack_complex_double,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zuncsd_(
jobu1: *const c_char,
jobu2: *const c_char,
jobv1t: *const c_char,
jobv2t: *const c_char,
trans: *const c_char,
signs: *const c_char,
m: *const lapack_int,
p: *const lapack_int,
q: *const lapack_int,
x11: *mut lapack_complex_double,
ldx11: *const lapack_int,
x12: *mut lapack_complex_double,
ldx12: *const lapack_int,
x21: *mut lapack_complex_double,
ldx21: *const lapack_int,
x22: *mut lapack_complex_double,
ldx22: *const lapack_int,
theta: *mut c_double,
u1: *mut lapack_complex_double,
ldu1: *const lapack_int,
u2: *mut lapack_complex_double,
ldu2: *const lapack_int,
v1t: *mut lapack_complex_double,
ldv1t: *const lapack_int,
v2t: *mut lapack_complex_double,
ldv2t: *const lapack_int,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
rwork: *mut c_double,
lrwork: *const lapack_int,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
pub fn zuncsd2by1_(
jobu1: *const c_char,
jobu2: *const c_char,
jobv1t: *const c_char,
m: *const lapack_int,
p: *const lapack_int,
q: *const lapack_int,
x11: *mut lapack_complex_double,
ldx11: *const lapack_int,
x21: *mut lapack_complex_double,
ldx21: *const lapack_int,
theta: *mut lapack_complex_double,
u1: *mut lapack_complex_double,
ldu1: *const lapack_int,
u2: *mut lapack_complex_double,
ldu2: *const lapack_int,
v1t: *mut lapack_complex_double,
ldv1t: *const lapack_int,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
rwork: *mut c_double,
lrwork: *const lapack_int,
iwork: *mut lapack_int,
info: *mut lapack_int,
);
// Version 3.4.0
pub fn sgemqrt_(
side: *const c_char,
trans: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
nb: *const lapack_int,
v: *const c_float,
ldv: *const lapack_int,
t: *const c_float,
ldt: *const lapack_int,
c: *mut c_float,
ldc: *const lapack_int,
work: *mut c_float,
info: *mut lapack_int,
);
pub fn dgemqrt_(
side: *const c_char,
trans: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
nb: *const lapack_int,
v: *const c_double,
ldv: *const lapack_int,
t: *const c_double,
ldt: *const lapack_int,
c: *mut c_double,
ldc: *const lapack_int,
work: *mut c_double,
info: *mut lapack_int,
);
pub fn cgemqrt_(
side: *const c_char,
trans: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
nb: *const lapack_int,
v: *const lapack_complex_float,
ldv: *const lapack_int,
t: *const lapack_complex_float,
ldt: *const lapack_int,
c: *mut lapack_complex_float,
ldc: *const lapack_int,
work: *mut lapack_complex_float,
info: *mut lapack_int,
);
pub fn zgemqrt_(
side: *const c_char,
trans: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
nb: *const lapack_int,
v: *const lapack_complex_double,
ldv: *const lapack_int,
t: *const lapack_complex_double,
ldt: *const lapack_int,
c: *mut lapack_complex_double,
ldc: *const lapack_int,
work: *mut lapack_complex_double,
info: *mut lapack_int,
);
pub fn sgeqrt_(
m: *const lapack_int,
n: *const lapack_int,
nb: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
t: *mut c_float,
ldt: *const lapack_int,
work: *mut c_float,
info: *mut lapack_int,
);
pub fn dgeqrt_(
m: *const lapack_int,
n: *const lapack_int,
nb: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
t: *mut c_double,
ldt: *const lapack_int,
work: *mut c_double,
info: *mut lapack_int,
);
pub fn cgeqrt_(
m: *const lapack_int,
n: *const lapack_int,
nb: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
t: *mut lapack_complex_float,
ldt: *const lapack_int,
work: *mut lapack_complex_float,
info: *mut lapack_int,
);
pub fn zgeqrt_(
m: *const lapack_int,
n: *const lapack_int,
nb: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
t: *mut lapack_complex_double,
ldt: *const lapack_int,
work: *mut lapack_complex_double,
info: *mut lapack_int,
);
pub fn sgeqrt2_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
t: *mut c_float,
ldt: *const lapack_int,
info: *mut lapack_int,
);
pub fn dgeqrt2_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
t: *mut c_double,
ldt: *const lapack_int,
info: *mut lapack_int,
);
pub fn cgeqrt2_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
t: *mut lapack_complex_float,
ldt: *const lapack_int,
info: *mut lapack_int,
);
pub fn zgeqrt2_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
t: *mut lapack_complex_double,
ldt: *const lapack_int,
info: *mut lapack_int,
);
pub fn sgeqrt3_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
t: *mut c_float,
ldt: *const lapack_int,
info: *mut lapack_int,
);
pub fn dgeqrt3_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
t: *mut c_double,
ldt: *const lapack_int,
info: *mut lapack_int,
);
pub fn cgeqrt3_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
t: *mut lapack_complex_float,
ldt: *const lapack_int,
info: *mut lapack_int,
);
pub fn zgeqrt3_(
m: *const lapack_int,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
t: *mut lapack_complex_double,
ldt: *const lapack_int,
info: *mut lapack_int,
);
pub fn stpmqrt_(
side: *const c_char,
trans: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
l: *const lapack_int,
nb: *const lapack_int,
v: *const c_float,
ldv: *const lapack_int,
t: *const c_float,
ldt: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
b: *mut c_float,
ldb: *const lapack_int,
work: *mut c_float,
info: *mut lapack_int,
);
pub fn dtpmqrt_(
side: *const c_char,
trans: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
l: *const lapack_int,
nb: *const lapack_int,
v: *const c_double,
ldv: *const lapack_int,
t: *const c_double,
ldt: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
b: *mut c_double,
ldb: *const lapack_int,
work: *mut c_double,
info: *mut lapack_int,
);
pub fn ctpmqrt_(
side: *const c_char,
trans: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
l: *const lapack_int,
nb: *const lapack_int,
v: *const lapack_complex_float,
ldv: *const lapack_int,
t: *const lapack_complex_float,
ldt: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
work: *mut lapack_complex_float,
info: *mut lapack_int,
);
pub fn ztpmqrt_(
side: *const c_char,
trans: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
l: *const lapack_int,
nb: *const lapack_int,
v: *const lapack_complex_double,
ldv: *const lapack_int,
t: *const lapack_complex_double,
ldt: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
work: *mut lapack_complex_double,
info: *mut lapack_int,
);
pub fn stpqrt_(
m: *const lapack_int,
n: *const lapack_int,
l: *const lapack_int,
nb: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
b: *mut c_float,
ldb: *const lapack_int,
t: *mut c_float,
ldt: *const lapack_int,
work: *mut c_float,
info: *mut lapack_int,
);
pub fn dtpqrt_(
m: *const lapack_int,
n: *const lapack_int,
l: *const lapack_int,
nb: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
b: *mut c_double,
ldb: *const lapack_int,
t: *mut c_double,
ldt: *const lapack_int,
work: *mut c_double,
info: *mut lapack_int,
);
pub fn ctpqrt_(
m: *const lapack_int,
n: *const lapack_int,
l: *const lapack_int,
nb: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
t: *mut lapack_complex_float,
ldt: *const lapack_int,
work: *mut lapack_complex_float,
info: *mut lapack_int,
);
pub fn ztpqrt_(
m: *const lapack_int,
n: *const lapack_int,
l: *const lapack_int,
nb: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
t: *mut lapack_complex_double,
ldt: *const lapack_int,
work: *mut lapack_complex_double,
info: *mut lapack_int,
);
pub fn stpqrt2_(
m: *const lapack_int,
n: *const lapack_int,
l: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
b: *mut c_float,
ldb: *const lapack_int,
t: *mut c_float,
ldt: *const lapack_int,
info: *mut lapack_int,
);
pub fn dtpqrt2_(
m: *const lapack_int,
n: *const lapack_int,
l: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
b: *mut c_double,
ldb: *const lapack_int,
t: *mut c_double,
ldt: *const lapack_int,
info: *mut lapack_int,
);
pub fn ctpqrt2_(
m: *const lapack_int,
n: *const lapack_int,
l: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
t: *mut lapack_complex_float,
ldt: *const lapack_int,
info: *mut lapack_int,
);
pub fn ztpqrt2_(
m: *const lapack_int,
n: *const lapack_int,
l: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
t: *mut lapack_complex_double,
ldt: *const lapack_int,
info: *mut lapack_int,
);
pub fn stprfb_(
side: *const c_char,
trans: *const c_char,
direct: *const c_char,
storev: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
l: *const lapack_int,
v: *const c_float,
ldv: *const lapack_int,
t: *const c_float,
ldt: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
b: *mut c_float,
ldb: *const lapack_int,
work: *const c_float,
ldwork: *const lapack_int,
);
pub fn dtprfb_(
side: *const c_char,
trans: *const c_char,
direct: *const c_char,
storev: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
l: *const lapack_int,
v: *const c_double,
ldv: *const lapack_int,
t: *const c_double,
ldt: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
b: *mut c_double,
ldb: *const lapack_int,
work: *const c_double,
ldwork: *const lapack_int,
);
pub fn ctprfb_(
side: *const c_char,
trans: *const c_char,
direct: *const c_char,
storev: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
l: *const lapack_int,
v: *const lapack_complex_float,
ldv: *const lapack_int,
t: *const lapack_complex_float,
ldt: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
work: *mut lapack_complex_float,
ldwork: *const lapack_int,
);
pub fn ztprfb_(
side: *const c_char,
trans: *const c_char,
direct: *const c_char,
storev: *const c_char,
m: *const lapack_int,
n: *const lapack_int,
k: *const lapack_int,
l: *const lapack_int,
v: *const lapack_complex_double,
ldv: *const lapack_int,
t: *const lapack_complex_double,
ldt: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
work: *mut lapack_complex_double,
ldwork: *const lapack_int,
);
// Version 3.5.0
pub fn ssysv_rook_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
ipiv: *mut lapack_int,
b: *mut c_float,
ldb: *const lapack_int,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dsysv_rook_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
ipiv: *mut lapack_int,
b: *mut c_double,
ldb: *const lapack_int,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn csysv_rook_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
ipiv: *mut lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zsysv_rook_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
ipiv: *mut lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn ssytrf_rook_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut c_float,
lda: *const lapack_int,
ipiv: *mut lapack_int,
work: *mut c_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn dsytrf_rook_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut c_double,
lda: *const lapack_int,
ipiv: *mut lapack_int,
work: *mut c_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn csytrf_rook_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
ipiv: *mut lapack_int,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zsytrf_rook_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
ipiv: *mut lapack_int,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn ssytrs_rook_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const c_float,
lda: *const lapack_int,
ipiv: *const lapack_int,
b: *mut c_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn dsytrs_rook_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const c_double,
lda: *const lapack_int,
ipiv: *const lapack_int,
b: *mut c_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn csytrs_rook_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
ipiv: *const lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn zsytrs_rook_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
ipiv: *const lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn chetrf_rook_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
ipiv: *mut lapack_int,
work: *mut lapack_complex_float,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn zhetrf_rook_(
uplo: *const c_char,
n: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
ipiv: *mut lapack_int,
work: *mut lapack_complex_double,
lwork: *const lapack_int,
info: *mut lapack_int,
);
pub fn chetrs_rook_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const lapack_complex_float,
lda: *const lapack_int,
ipiv: *const lapack_int,
b: *mut lapack_complex_float,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn zhetrs_rook_(
uplo: *const c_char,
n: *const lapack_int,
nrhs: *const lapack_int,
a: *const lapack_complex_double,
lda: *const lapack_int,
ipiv: *const lapack_int,
b: *mut lapack_complex_double,
ldb: *const lapack_int,
info: *mut lapack_int,
);
pub fn csyr_(
uplo: *const c_char,
n: *const lapack_int,
alpha: *const lapack_complex_float,
x: *const lapack_complex_float,
incx: *const lapack_int,
a: *mut lapack_complex_float,
lda: *const lapack_int,
);
pub fn zsyr_(
uplo: *const c_char,
n: *const lapack_int,
alpha: *const lapack_complex_double,
x: *const lapack_complex_double,
incx: *const lapack_int,
a: *mut lapack_complex_double,
lda: *const lapack_int,
);
pub fn ilaver_(
vers_major: *mut lapack_int,
vers_minor: *mut lapack_int,
vers_patch: *mut lapack_int,
);
}
|
// Pasts
//
// Copyright (c) 2019-2020 Jeron Aldaron Lau
//
// Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
// https://apache.org/licenses/LICENSE-2.0>, or the Zlib License, <LICENSE-ZLIB
// or http://opensource.org/licenses/Zlib>, at your option. This file may not be
// copied, modified, or distributed except according to those terms.
#![cfg_attr(feature = "docs-rs", feature(external_doc))]
#![cfg_attr(feature = "docs-rs", doc(include = "../README.md"))]
#![doc = ""]
#![cfg_attr(not(feature = "std"), no_std)]
#![doc(
html_logo_url = "https://libcala.github.io/logo.svg",
html_favicon_url = "https://libcala.github.io/icon.svg",
html_root_url = "https://docs.rs/pasts"
)]
#![deny(unsafe_code)]
#![warn(
anonymous_parameters,
missing_copy_implementations,
missing_debug_implementations,
missing_docs,
nonstandard_style,
rust_2018_idioms,
single_use_lifetimes,
trivial_casts,
trivial_numeric_casts,
unreachable_pub,
unused_extern_crates,
unused_qualifications,
variant_size_differences
)]
#[cfg(feature = "alloc")]
extern crate alloc;
/// Re-exported traits
pub mod prelude {
pub use crate::DynFut;
pub use crate::Executor;
pub use crate::Join;
pub use crate::Select;
#[cfg(feature = "std")]
pub use crate::DynBoxFut;
}
mod dyn_future;
mod executor;
mod join;
mod select;
pub use dyn_future::DynFut;
pub use dyn_future::DynFuture;
pub use executor::Executor;
pub use join::Join;
pub use select::Select;
#[cfg(feature = "std")]
mod cvar_exec;
#[cfg(feature = "std")]
mod spawner;
#[cfg(feature = "alloc")]
pub use dyn_future::DynBoxFut;
#[cfg(feature = "std")]
pub use cvar_exec::CvarExec;
#[cfg(feature = "std")]
pub use spawner::spawn_blocking;
|
use core::fmt;
use core::str::FromStr;
use crate::{base58, hash, error};
use byteorder::{ByteOrder, LittleEndian};
/// An secp256k1 signature.
#[derive(Clone, PartialEq, Eq, Debug)]
pub struct Signature {
pub recv_id: secp256k1::RecoveryId,
pub sig: secp256k1::Signature,
}
impl Signature {
pub fn is_canonical(&self) -> bool {
self.sig.is_canonical()
}
pub fn serialize_compact(&self) -> [u8; 65] {
let mut data: [u8; 65] = [0u8; 65];
data[0] = self.recv_id.serialize() + 27 + 4;
data[1..65].copy_from_slice(&self.sig.serialize());
data
}
pub fn from_compact(data: &[u8; 65]) -> crate::Result<Self> {
let recv_id = if data[0] >= 31 {
data[0] - 4
} else {
data[0]
};
let recv_id = secp256k1::RecoveryId::parse_rpc(recv_id)?;
let sig = secp256k1::Signature::parse_slice(&data[1..])?;
Ok(Self {
recv_id,
sig,
})
}
}
impl FromStr for Signature {
type Err = error::Error;
fn from_str(s: &str) -> crate::Result<Signature> {
if !s.starts_with("SIG_K1_") {
return Err(secp256k1::Error::InvalidSignature.into());
}
let s_hex = base58::from(&s[7..])?;
// recovery id length: 1
// signature length: 64
// checksum length: 4
if s_hex.len() != 1 + 64 + 4 {
return Err(secp256k1::Error::InvalidSignature.into());
}
let mut recv_id = s_hex[0];
if recv_id >= 4 + 27 {
recv_id = recv_id - 4 - 27
}
let recv_id = secp256k1::RecoveryId::parse(recv_id)
.map_err(|err| error::Error::Secp256k1(err))?;
let data = &s_hex[1..65];
// Verify checksum
let mut checksum_data = [0u8; 67];
checksum_data[..65].copy_from_slice(&s_hex[..65]);
checksum_data[65..67].copy_from_slice(b"K1");
let expected = LittleEndian::read_u32(&hash::ripemd160(&checksum_data)[..4]);
let actual = LittleEndian::read_u32(&s_hex[65..69]);
if expected != actual {
return Err(base58::Error::BadChecksum(expected, actual).into());
}
let sig = secp256k1::Signature::parse_slice(data)
.map_err(|err| error::Error::Secp256k1(err))?;
Ok(Signature {
recv_id,
sig
})
}
}
impl fmt::Display for Signature {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let recv_id = self.recv_id;
let sig = self.sig.clone();
// See https://github.com/EOSIO/fc/blob/f4755d330faf9d2342d646a93f9a27bf68ca759e/src/crypto/elliptic_impl_priv.cpp
let mut checksum_data: [u8; 67] = [0u8; 67];
let recovery_id_i32: u8 = recv_id.into();
checksum_data[0] = recovery_id_i32 + 4 + 27;
checksum_data[1..65].copy_from_slice(&sig.serialize());
checksum_data[65..].copy_from_slice(b"K1");
// Compute ripemd160 checksum
let checksum_h160 = hash::ripemd160(&checksum_data);
let checksum = &checksum_h160.take()[..4];
// Signature slice
let mut sig_slice: [u8; 69] = [0u8; 69];
sig_slice[..65].copy_from_slice(&checksum_data[..65]);
sig_slice[65..].copy_from_slice(&checksum[..]);
write!(f, "SIG_K1_{}", base58::encode_slice(&sig_slice))?;
Ok(())
}
}
#[cfg(test)]
mod test {
use super::Signature;
use core::str::FromStr;
use alloc::string::ToString;
#[test]
fn sig_from_str_should_work() {
let sig_str = "SIG_K1_KBJgSuRYtHZcrWThugi4ygFabto756zuQQo8XeEpyRtBXLb9kbJtNW3xDcS14Rc14E8iHqLrdx46nenG5T7R4426Bspyzk";
let sig = Signature::from_str(sig_str);
assert!(sig.is_ok());
let sig = sig.unwrap();
assert!(sig.is_canonical());
assert_eq!(sig.to_string(), sig_str);
}
#[test]
fn sig_from_str_should_error() {
let sig_str = "KomV6FEHKdtZxGDwhwSubEAcJ7VhtUQpEt5P6iDz33ic936aSXx87B2L56C8JLQkqNpp1W8ZXjrKiLHUEB4LCGeXvbtVuR";
let sig = Signature::from_str(sig_str);
assert!(sig.is_err());
}
}
|
use std::{
net::{IpAddr, SocketAddr},
str::FromStr,
};
#[derive(Clone, Debug)]
struct Addr {
addr: IpAddr,
port: Option<u16>,
}
impl std::fmt::Display for Addr {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let ipv = if self.addr.is_ipv4() { "4" } else { "6" };
let hex = match self.addr {
IpAddr::V4(addr) => u32::from(addr) as u128,
IpAddr::V6(addr) => u128::from(addr),
};
match self.port {
Some(p) => write!(
f,
"address: {}, port: {}, hex: {:x} (IPv{})",
self.addr, p, hex, ipv
),
None => write!(
f,
"address: {}, port: N/A, hex: {:x} (IPv{}) ",
self.addr, hex, ipv
),
}
}
}
impl FromStr for Addr {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
if let Ok(addr) = s.parse::<IpAddr>() {
Ok(Self { addr, port: None })
} else if let Ok(sock) = s.parse::<SocketAddr>() {
Ok(Self {
addr: sock.ip(),
port: Some(sock.port()),
})
} else {
Err(())
}
}
}
fn print_addr(s: &str) {
match s.parse::<Addr>() {
Ok(addr) => println!("{}: {}", s, addr),
_ => println!("{} not a valid address", s),
}
}
fn main() {
[
"127.0.0.1",
"127.0.0.1:80",
"::1",
"[::1]:80",
"2605:2700:0:3::4713:93e3",
"[2605:2700:0:3::4713:93e3]:80",
]
.iter()
.cloned()
.for_each(print_addr);
} |
extern crate serde;
extern crate serde_json;
extern crate serde_xml_rs;
use std::collections::HashSet;
use std::fs::File;
use std::io::prelude::*;
use std::io::BufReader;
use std::iter::FromIterator;
use std::option::Option;
use std::path::PathBuf;
use std::{thread, time};
use log::{info, warn};
use serde::{Deserialize, Serialize};
use anyhow::Result;
use crate::ena::{species, EnaTaxonInfo};
#[derive(Debug, Deserialize, Serialize, PartialEq, Clone)]
pub enum Rank {
Species,
Genus,
Family,
Order,
Class,
Phylum,
Kingdom,
Superkingdom,
Root,
}
impl Rank {
pub fn from_string(rank: &String) -> Option<Self> {
return match rank.as_ref() {
"species" => Some(Self::Species),
"genus" => Some(Self::Genus),
"family" => Some(Self::Family),
"order" => Some(Self::Order),
"class" => Some(Self::Class),
"phylum" => Some(Self::Phylum),
"kingdom" => Some(Self::Kingdom),
"superkingdom" => Some(Self::Superkingdom),
"root" => Some(Self::Root),
_ => None,
};
}
pub fn ascending() -> Vec<Self> {
return vec![
Rank::Species,
Rank::Genus,
Rank::Family,
Rank::Order,
Rank::Class,
Rank::Phylum,
Rank::Kingdom,
Rank::Superkingdom,
Rank::Root,
];
}
}
#[derive(Debug, Deserialize, Serialize, PartialEq)]
pub struct TaxonInfo {
pub name: String,
pub taxid: usize,
pub rank: Rank,
}
#[derive(Debug, Deserialize, Serialize, PartialEq)]
pub struct Mapping {
pub taxid: usize,
pub name: Option<String>,
pub species: Option<TaxonInfo>,
pub genus: Option<TaxonInfo>,
pub family: Option<TaxonInfo>,
pub order: Option<TaxonInfo>,
pub class: Option<TaxonInfo>,
pub phylum: Option<TaxonInfo>,
pub kingdom: Option<TaxonInfo>,
pub superkingdom: Option<TaxonInfo>,
pub root: Option<TaxonInfo>,
}
impl Mapping {
pub fn taxon_at(&self, rank: &Rank) -> Option<&TaxonInfo> {
match rank {
Rank::Species => self.species.as_ref(),
Rank::Genus => self.genus.as_ref(),
Rank::Family => self.family.as_ref(),
Rank::Order => self.order.as_ref(),
Rank::Class => self.class.as_ref(),
Rank::Phylum => self.phylum.as_ref(),
Rank::Kingdom => self.kingdom.as_ref(),
Rank::Superkingdom => self.superkingdom.as_ref(),
Rank::Root => self.root.as_ref(),
}
}
pub fn is_empty(&self) -> bool {
if self.taxid == 131567 {
return false;
}
return self.species.is_none()
&& self.genus.is_none()
&& self.family.is_none()
&& self.order.is_none()
&& self.class.is_none()
&& self.phylum.is_none()
&& self.kingdom.is_none()
&& self.superkingdom.is_none();
}
}
#[derive(Debug)]
struct Report {
total: usize,
mapped: usize,
unmapped: usize,
}
fn lineage_mapping(taxon: &EnaTaxonInfo) -> Mapping {
let mut mapping = Mapping {
name: Some(taxon.name.clone()),
taxid: taxon.taxid,
species: None,
genus: None,
family: None,
order: None,
class: None,
phylum: None,
kingdom: None,
superkingdom: None,
root: Some(TaxonInfo {
name: String::from("cellular organisms"),
taxid: 131567,
rank: Rank::Root,
}),
};
if taxon.rank == Some(String::from("species")) {
mapping.species = Some(TaxonInfo {
name: taxon.name.clone(),
taxid: taxon.taxid,
rank: Rank::Species,
})
}
for parent in taxon.parent_taxons() {
let rank: Option<Rank> = parent.rank.as_ref().and_then(|r| Rank::from_string(&r));
if rank.is_none() {
continue;
}
let rank = rank.unwrap();
let tinfo = TaxonInfo {
name: parent.name.to_string(),
taxid: parent.taxid,
rank: rank.clone(),
};
match rank {
Rank::Species => mapping.species = Some(tinfo),
Rank::Genus => mapping.genus = Some(tinfo),
Rank::Family => mapping.family = Some(tinfo),
Rank::Order => mapping.order = Some(tinfo),
Rank::Class => mapping.class = Some(tinfo),
Rank::Phylum => mapping.phylum = Some(tinfo),
Rank::Kingdom => mapping.kingdom = Some(tinfo),
Rank::Superkingdom => mapping.superkingdom = Some(tinfo),
Rank::Root => mapping.root = Some(tinfo),
}
}
return mapping;
}
fn mappings(taxids: &[usize]) -> Result<Vec<Mapping>> {
let species = species(taxids)?;
let mut missing: HashSet<usize> = HashSet::from_iter(taxids.iter().cloned());
let mut mappings = Vec::new();
for entry in species {
let info = lineage_mapping(&entry);
mappings.push(info);
missing.remove(&entry.taxid);
}
let extra = missing.iter().map(|taxid| Mapping {
taxid: *taxid,
name: None,
species: None,
genus: None,
family: None,
order: None,
class: None,
phylum: None,
kingdom: None,
superkingdom: None,
root: None,
});
mappings.extend(extra);
return Ok(mappings);
}
pub fn write_lineage(chunk_size: usize, filename: PathBuf) -> Result<()> {
let file = File::open(filename)?;
let reader = BufReader::new(file);
let taxids = reader
.lines()
.into_iter()
.map(|l| l.unwrap().trim().parse::<usize>().unwrap());
let mut report = Report {
total: 0,
mapped: 0,
unmapped: 0,
};
for chunk in taxids.collect::<Vec<usize>>().chunks(chunk_size) {
report.total += chunk.len();
let mappings = mappings(chunk)?;
for mapping in mappings {
match mapping.is_empty() {
true => {
report.unmapped += 1;
warn!("No mapping found for {}", mapping.taxid);
}
false => {
report.mapped += 1;
println!("{}", serde_json::to_string(&mapping)?);
}
}
}
let dur = time::Duration::from_millis(200);
thread::sleep(dur)
}
info!("Status: {:?}", report);
return Ok(());
}
|
use std::convert::TryFrom;
use std::str::FromStr;
use neon::prelude::{FunctionContext, JsObject, JsResult, JsString, JsNumber};
use uuid::Uuid;
use access::{VaultConfig, WrappedVault, args_get_str};
use emerald_vault::{convert::{
json::keyfile::EthereumJsonV3File
}, core::chains::Blockchain, mnemonic::HDPath, storage::error::VaultError, trim_hex, structs::wallet::Wallet, PrivateKey};
use json::StatusResult;
use emerald_vault::structs::wallet::AccountId;
#[derive(Deserialize, Clone)]
pub struct AddAccountJson {
pub blockchain: u32,
#[serde(flatten)]
pub key_value: AddAccountType,
pub password: Option<String>
}
#[derive(Deserialize, Clone)]
#[serde(tag = "type", content = "key")]
pub enum AddAccountType {
#[serde(rename = "ethereum-json")]
EthereumJson(String),
#[serde(rename = "raw-pk-hex")]
RawHex(String),
#[serde(rename = "hd-path")]
HdPath(SeedAccount),
#[serde(rename = "generate-random")]
GenerateRandom
}
#[derive(Deserialize, Clone)]
pub struct SeedAccount {
#[serde(rename = "seedId")]
pub seed_id: String,
#[serde(rename = "hdPath")]
pub hd_path: String,
pub password: String,
pub address: Option<String>
}
#[derive(Serialize, Clone)]
pub struct WalletAccountJson {
pub id: String,
pub blockchain: u32,
pub address: Option<String>,
}
#[derive(Serialize, Clone)]
pub struct WalletJson {
pub id: String,
pub name: Option<String>,
pub accounts: Vec<WalletAccountJson>
}
impl From<Wallet> for WalletJson {
fn from(wallet: Wallet) -> Self {
let accounts: Vec<WalletAccountJson> = wallet.accounts.iter()
.map(|a| WalletAccountJson {
id: AccountId::from(&wallet, a).to_string(),
blockchain: a.blockchain as u32,
address: a.address.map(|v| v.to_string())
})
.collect();
WalletJson {
id: wallet.id.clone().to_string(),
name: wallet.label,
accounts
}
}
}
fn read_wallet_id(cx: &mut FunctionContext, pos: i32) -> Uuid {
let wallet_id = cx.argument::<JsString>(pos).expect("wallet_id is not provided").value();
let wallet_id = Uuid::parse_str(wallet_id.as_str()).expect("Invalid UUID");
wallet_id
}
fn read_wallet_and_account_ids(cx: &mut FunctionContext, pos: i32) -> (Uuid, usize) {
let wallet_id = cx.argument::<JsString>(pos).expect("wallet_id is not provided").value();
let wallet_id = Uuid::parse_str(wallet_id.as_str()).expect("Invalid UUID");
let account_id = cx.argument::<JsNumber>(pos + 1).expect("account_id is not provided").value();
let account_id = account_id as usize;
(wallet_id, account_id)
}
impl WrappedVault {
fn create_wallet(&self, label: Option<String>) -> Result<Uuid, VaultError> {
let storage = &self.cfg.get_storage();
let id = Uuid::new_v4();
storage.wallets().add(Wallet {
id: id.clone(),
label,
..Wallet::default()
}).map(|_| id)
}
fn create_account(&self, wallet_id: Uuid, account: AddAccountJson) -> Result<usize, VaultError> {
let blockchain = Blockchain::try_from(account.blockchain)?;
let storage = &self.cfg.get_storage();
let result = match account.key_value {
AddAccountType::EthereumJson(json) => {
let json = EthereumJsonV3File::try_from(json)?;
let id = storage.add_account(wallet_id)
.ethereum(&json, blockchain)?;
id
},
AddAccountType::RawHex(hex) => {
if account.password.is_none() {
panic!("Password is required".to_string())
}
let hex = trim_hex(hex.as_str());
let hex = hex::decode(hex)?;
storage.add_account(wallet_id)
.raw_pk(hex, account.password.unwrap().as_str(), blockchain)?
},
AddAccountType::HdPath(hd) => {
storage.add_account(wallet_id)
.seed_hd(Uuid::from_str(hd.seed_id.as_str())?,
HDPath::try_from(hd.hd_path.as_str())?,
blockchain,
Some(hd.password),
None)?
},
AddAccountType::GenerateRandom => {
if account.password.is_none() {
panic!("Password is required".to_string())
}
let pk = PrivateKey::gen();
storage.add_account(wallet_id)
.raw_pk(pk.0.to_vec(), account.password.unwrap().as_str(), blockchain)?
}
};
Ok(result)
}
fn set_title(&self, wallet_id: Uuid, title: Option<String>) -> Result<(), VaultError> {
let storage = &self.cfg.get_storage();
let mut wallet = storage.wallets().get(wallet_id)?;
wallet.label = title;
storage.wallets().update(wallet)?;
Ok(())
}
fn remove_account(&self, wallet_id: Uuid, account_id: usize) -> Result<bool, VaultError> {
let storage = &self.cfg.get_storage();
let mut wallet = storage.wallets().get(wallet_id)?;
let index = wallet.accounts.iter().position(|a| a.id == account_id);
if index.is_none() {
return Ok(false)
}
wallet.accounts.remove(index.unwrap());
storage.wallets().update(wallet)
}
}
pub fn list(mut cx: FunctionContext) -> JsResult<JsObject> {
let cfg = VaultConfig::get_config(&mut cx);
let vault = WrappedVault::new(cfg);
let wallets = vault.load_wallets();
let mut result = Vec::new();
for w in wallets {
result.push(WalletJson::from(w));
}
let status = StatusResult::Ok(result).as_json();
let js_value = neon_serde::to_value(&mut cx, &status)?;
Ok(js_value.downcast().unwrap())
}
pub fn add(mut cx: FunctionContext) -> JsResult<JsObject> {
let cfg = VaultConfig::get_config(&mut cx);
let vault = WrappedVault::new(cfg);
let label = cx.argument::<JsString>(1)
.ok()
.map(|x| x.value());
let id = vault.create_wallet(label).expect("Wallet not created");
let status = StatusResult::Ok(id.to_string()).as_json();
let js_value = neon_serde::to_value(&mut cx, &status)?;
Ok(js_value.downcast().unwrap())
}
pub fn add_account_to_wallet(mut cx: FunctionContext) -> JsResult<JsObject> {
let cfg = VaultConfig::get_config(&mut cx);
let vault = WrappedVault::new(cfg);
let wallet_id =read_wallet_id(&mut cx, 1);
let json = cx.argument::<JsString>(2).expect("Input JSON is not provided").value();
let parsed: AddAccountJson = serde_json::from_str(json.as_str()).expect("Invalid JSON");
let id = vault.create_account(wallet_id, parsed).expect("Account not created");
let status = StatusResult::Ok(id).as_json();
let js_value = neon_serde::to_value(&mut cx, &status)?;
Ok(js_value.downcast().unwrap())
}
pub fn update_label(mut cx: FunctionContext) -> JsResult<JsObject> {
let cfg = VaultConfig::get_config(&mut cx);
let vault = WrappedVault::new(cfg);
let wallet_id =read_wallet_id(&mut cx, 1);
let title = args_get_str(&mut cx, 2);
let result = vault.set_title(wallet_id, title).is_ok();
let status = StatusResult::Ok(result).as_json();
let js_value = neon_serde::to_value(&mut cx, &status)?;
Ok(js_value.downcast().unwrap())
}
pub fn remove_account(mut cx: FunctionContext) -> JsResult<JsObject> {
let cfg = VaultConfig::get_config(&mut cx);
let vault = WrappedVault::new(cfg);
let (wallet_id, account_id) = read_wallet_and_account_ids(&mut cx, 1);
let result = vault.remove_account(wallet_id, account_id).expect("Not deleted");
let status = StatusResult::Ok(result).as_json();
let js_value = neon_serde::to_value(&mut cx, &status)?;
Ok(js_value.downcast().unwrap())
} |
use unreachable::unreachable;
use io::WriteExt;
use std::process;
use std::error::Error;
use std::io::{self, Write};
/// Extension for Option-like types
pub trait OptionalExt {
/// The "success" variant of this optional type.
type Succ;
/// Unwrap or abort program with exit code
fn try(self, stderr: &mut io::Stderr) -> Self::Succ;
/// Unwrap or abort the program with failed exit code and custom error message
fn fail<'a>(self, err: &'a str, stderr: &mut io::Stderr) -> Self::Succ;
/// An unwrapping where the fail-case is not checked and threaten as statical unreachable.
unsafe fn unchecked_unwrap(self) -> Self::Succ;
}
impl<T, U: Error> OptionalExt for Result<T, U> {
type Succ = T;
fn try(self, stderr: &mut io::Stderr) -> T {
let mut stderr = stderr.lock();
match self {
Ok(succ) => succ,
Err(e) => {
// We ignore the results to avoid stack overflow (because of unbounded
// recursion).
let _ = stderr.write(b"error: ");
let _ = stderr.write(e.description().as_bytes());
let _ = stderr.write(b"\n");
let _ = stderr.flush();
process::exit(1);
},
}
}
fn fail<'a>(self, err: &'a str, stderr: &mut io::Stderr) -> T {
let mut stderr = stderr.lock();
match self {
Ok(succ) => succ,
Err(_) => {
let _ = stderr.write(b"error: ");
let _ = stderr.write(err.as_bytes());
let _ = stderr.write(b"\n");
let _ = stderr.flush();
process::exit(1);
},
}
}
unsafe fn unchecked_unwrap(self) -> T {
if let Ok(x) = self {
x
} else {
unreachable()
}
}
}
impl<T> OptionalExt for Option<T> {
type Succ = T;
fn try(self, stderr: &mut io::Stderr) -> T {
let mut stderr = stderr.lock();
match self {
Some(succ) => succ,
None => {
let _ = stderr.writeln(b"error: (no message)\n");
let _ = stderr.flush();
process::exit(1);
},
}
}
fn fail<'a>(self, err: &'a str, stderr: &mut io::Stderr) -> T {
let mut stderr = stderr.lock();
match self {
Some(succ) => succ,
None => {
let _ = stderr.write(b"error:");
let _ = stderr.write(err.as_bytes());
let _ = stderr.write(b"\n");
let _ = stderr.flush();
process::exit(1);
},
}
}
unsafe fn unchecked_unwrap(self) -> T {
if let Some(x) = self {
x
} else {
unreachable()
}
}
}
/// A generalization of `try!()`.
///
/// If this optional (`Option`-like) type is successful, return the inner value. If not, evaluate
/// the expression right to the arrow.
///
/// ## How is this different than `unwrap_or()`?
///
/// Unwrap or evaluates inside an closure, thus it cannot access various statement related to
/// control flow. For example, `return` will return the value from the closure, whereas `maybe!`,
/// will expand the statement inline, such that the current function will return.
#[macro_export]
macro_rules! maybe {
($x:expr) => {
if let Some(x) = $x {
x
} else {
return None;
}
};
($a:expr => $b:expr) => {
if let Some(x) = $a.into_iter().next() {
x
} else {
$b
}
};
}
#[cfg(test)]
mod test {
#[test]
fn test_maybe() {
fn func() -> Option<u8> {
loop {
maybe!(None => break);
}
maybe!(None);
unreachable!();
}
assert!(func().is_none());
}
}
|
use std::env;
use std::path::Path;
use anyhow::Error;
fn main() -> Result<(), Error> {
let crate_dir = env::var("CARGO_MANIFEST_DIR")?;
let crate_dir = Path::new(&crate_dir);
if cfg!(feature = "capi") {
cbindgen::Builder::new()
.with_crate(&crate_dir)
.with_config(cbindgen::Config::from_root_or_default(&crate_dir))
.generate()?
.write_to_file(crate_dir.join("include/hassh.h"));
}
Ok(())
}
|
#[macro_use] extern crate itertools;
use petgraph::graphmap::*;
use petgraph::visit::*;
use petgraph::algo::*;
//use multimap::MultiMap;
fn generate_differences(sorted: &[i32], diff: i32) -> Vec<(i32, i32)> {
return iproduct!(sorted, sorted)
.map(|(x, y)| (*x, *y))
.filter(|(x, y)| y - x > 0 && y - x <= diff)
.collect();
}
fn generate_segments(sorted: &[i32], diff: i32) -> Vec<Vec<(i32, i32)> > {
let mut result: Vec<Vec<(i32, i32)>> = Vec::new();
let all = generate_differences(sorted, diff);
let mut index = 0;
let mut last = 0;
while index + 1 < all.len() {
if all[index + 1].1 - all[index + 1].0 == diff &&
all[index].0 != all[index + 1].0
{
let to_push: Vec<(i32, i32)> = (&all[last..index+1]).iter().map(|x| *x).collect();
result.push(to_push);
last = index + 1;
}
index = index + 1;
}
return result;
}
fn count_differences(sorted: &[i32], diff: i32) -> usize {
let mut count = 0;
let mut index = 0;
while sorted.get(index+1).is_some() {
if sorted[index+1] - sorted[index] == diff {
count = count + 1;
}
index = index + 1;
}
return count;
}
//fn count_paths(map: &MultiMap<i32, i32>, node: i32) -> usize {
// let opt = map.get_vec(&node);
// if opt.is_some() {
// let vec = opt.unwrap();
// let mut count = vec.len();
// for n in vec {
// count = count * count_paths(map, *n);
// }
// return count;
// }
// else {
// return 1;
// }
//
//}
fn main() {
let args: Vec<String> = std::env::args().collect();
let filename = &args[1];
let contents = std::fs::read_to_string(filename).expect("File not found");
let mut numbers: Vec<i32> = contents.trim().lines().map(|x| x.parse::<i32>().unwrap()).collect();
let socket: i32 = 0;
numbers.push(socket); // plug
numbers.sort();
let device = numbers.last().unwrap() + 3;
numbers.push(device); // device
let segments = generate_segments(&numbers, 3);
println!("{:?}", segments);
let path_count = segments.iter().map(|x| {
let graph = DiGraphMap::<i32, i32>::from_edges(x);
let paths = all_simple_paths::<Vec<_>, _>(&graph, x.first().unwrap().0, x.last().unwrap().1, 0, None);
paths.count()
}).fold(1, |acc, c| acc * c);
println!("path count={}", path_count);
// println!("{:?}", path_counts);
// let edges = generate_differences(&numbers, 3);
// println!("{:?}", edges);
//
// let graph = DiGraphMap::<i32, i32>::from_edges(edges);
// let paths = all_simple_paths::<Vec<_>, _>(&graph, socket, device, 0, None);
// println!("number of simple paths= {}", paths.count());
}
|
//! Implement the Client and most actual functionality
//! for it.
//!
//! Most functions were implemented using the RFC959 as reference
//! and may not work as expected with deviant server implementations.
use crate::status_code::{StatusCode, StatusCodeKind};
use log::warn;
use std::net::ToSocketAddrs;
use tokio::io::{AsyncBufReadExt, AsyncReadExt, AsyncWriteExt, BufReader};
use tokio::net::TcpStream;
/// Represents a raw server response, with
/// a status code and the message after it.
///
/// Note that usual FTP responses follow the format:
/// STATUS_CODE: MESSAGE.
#[derive(Debug, PartialEq)]
pub struct ServerResponse {
message: String,
status_code: StatusCode,
}
impl ServerResponse {
/// Summarize an error message, when a response is not one of the expect
/// status codes provided.
pub fn summarize_error(&self, expected: Vec<StatusCodeKind>) -> String {
format!(
"Got {}: {}, expected {:?}",
self.status_code.code, self.message, expected
)
}
}
/// A FTP client can run in two main modes: active and passive.
///
/// The passive mode is the simpler to run, you simply ask the
/// server for a host to connect and connect to it, this is your
/// data connection (for more information about the FTP protocol, check
/// RFC959).
///
/// The active mode is different, you must open a port on your machine
/// and use that to connect to the server. This can be a problem if you
/// have firewalls set on your machine/network, for the common user, the
/// passive mode should work fine.
///
/// The ExtendedPassive mode listed is simply the passive mode with support for
/// IPV6.
#[derive(Debug, Clone, Copy)]
pub enum ClientMode {
/// The passive mode, using the PASV command
Passive,
/// The extended passive mode, using the EPSV command
ExtendedPassive,
/// The active mode, not implemented yet
Active,
}
impl ServerResponse {
/// Parse a server response from the server text response.
pub fn parse(text: &str) -> Self {
let status_code = StatusCode::parse(text);
let message = text[3..].trim().to_string();
Self {
message,
status_code,
}
}
/// Returns whether the status code returned indicates failure.
pub fn is_failure_status(&self) -> bool {
self.status_code.is_failure()
}
}
/// The Client is where most of the functionality is, it keeps
/// a control connection open and opens up data connections as
/// commands are issued. This struct is a very thin wrapper over
/// the FTP protocol.
pub struct Client {
stream: BufReader<TcpStream>,
buffer: String,
welcome_string: Option<String>,
mode: ClientMode,
}
impl Client {
/// Set the mode for the client.
pub fn set_mode(&mut self, mode: ClientMode) {
self.mode = mode
}
/// Connect to a new FTP server using plain text (no TLS).
pub async fn connect(
hostname: &str,
user: &str,
password: &str,
) -> Result<Self, crate::error::Error> {
Self::connect_with_port(hostname, 21, user, password).await
}
/// Connect to a new FTP server using plain text (no TLS) on a specific port.
pub async fn connect_with_port(
hostname: &str,
port: u32,
user: &str,
password: &str,
) -> Result<Self, crate::error::Error> {
let host = format!("{}:{}", hostname, port);
let addr = host.to_socket_addrs()?.next().unwrap();
let raw_stream = TcpStream::connect(&addr).await?;
let stream = BufReader::new(raw_stream);
let buffer = String::new();
let mut client = Client {
stream,
buffer,
welcome_string: None,
mode: ClientMode::ExtendedPassive,
};
let response = client
.parse_reply_expecting(vec![StatusCodeKind::ReadyForNewUser])
.await?;
client.welcome_string = Some(response.message);
client.login(user, password).await?;
Ok(client)
}
/// Get the welcome message sent by the server at the connection establishment.
pub fn get_welcome(&self) -> Option<&String> {
self.welcome_string.as_ref()
}
/// Login using the given user and password.
/// Note that many servers require a login with an anonymous user,
/// such as client.login("anonymous", "anonymous@mail.com").
pub async fn login(&mut self, user: &str, password: &str) -> Result<(), crate::error::Error> {
self.write_unary_command_expecting("USER", user, vec![StatusCodeKind::PasswordRequired])
.await?;
self.write_unary_command_expecting("PASS", password, vec![StatusCodeKind::UserLoggedIn])
.await?;
Ok(())
}
/// Logout from the current user/password pair.
pub async fn logout(&mut self) -> Result<(), crate::error::Error> {
self.write_command_expecting("QUIT", vec![StatusCodeKind::ClosingControlConnection])
.await?;
Ok(())
}
/// Change the working directory on the current session.
pub async fn cwd(&mut self, dir: &str) -> Result<(), crate::error::Error> {
self.write_unary_command_expecting(
"CWD",
dir,
vec![StatusCodeKind::RequestFileActionCompleted],
)
.await?;
Ok(())
}
/// Go up to the parent directory on the current session.
pub async fn cdup(&mut self) -> Result<(), crate::error::Error> {
self.write_command_expecting("CDUP", vec![StatusCodeKind::RequestFileActionCompleted])
.await?;
Ok(())
}
/// Show server information regarding its implementation status
/// to the user.
///
/// The help command can also be used with an argument to see detailed
/// information about a single command, this behaviour is not implemented.
pub async fn help(&mut self) -> Result<(), crate::error::Error> {
self.write_command_expecting(
"HELP",
vec![StatusCodeKind::SystemStatus, StatusCodeKind::HelpMessage],
)
.await?;
Ok(())
}
/// This command should not do anything other than receiving
/// an OK response from the server.
pub async fn noop(&mut self) -> Result<(), crate::error::Error> {
self.write_command_expecting("NOOP", vec![StatusCodeKind::Ok])
.await?;
Ok(())
}
/// Set the transfer type to ascii
pub async fn ascii(&mut self) -> Result<(), crate::error::Error> {
self.write_unary_command_expecting("TYPE", "A", vec![StatusCodeKind::Ok])
.await?;
Ok(())
}
/// Set the transfer type to binary
pub async fn binary(&mut self) -> Result<(), crate::error::Error> {
self.write_unary_command_expecting("TYPE", "I", vec![StatusCodeKind::Ok])
.await?;
Ok(())
}
/// Get the current reported status from the server. This can be used
/// during transfer and between them. This command can be used with
/// and argument to get behaviour similar to LIST, this particular
/// behaviour is not implemented.
pub async fn status(&mut self) -> Result<String, crate::error::Error> {
let response = self
.write_command_expecting("STAT", vec![StatusCodeKind::SystemStatus])
.await?;
Ok(response.message)
}
/// List the provided path in any way the server desires.
pub async fn list(&mut self, path: &str) -> Result<String, crate::error::Error> {
let mut conn = self.get_data_connection().await?;
self.write_unary_command_expecting(
"LIST",
path,
vec![
StatusCodeKind::TransferStarted,
StatusCodeKind::TransferAboutToStart,
],
)
.await?;
let mut buffer = Vec::with_capacity(1024);
conn.read_to_end(&mut buffer).await?;
self.parse_reply_expecting(vec![StatusCodeKind::RequestActionCompleted])
.await?;
let text = String::from_utf8(buffer).map_err(|_| {
crate::error::Error::SerializationFailed(
"Invalid ASCII returned on server directory listing.".to_string(),
)
})?;
Ok(text)
}
/// List the provided path, providing only name information about files and directories.
pub async fn list_names(&mut self, path: &str) -> Result<Vec<String>, crate::error::Error> {
let mut conn = self.get_data_connection().await?;
self.write_unary_command_expecting(
"NLST",
path,
vec![
StatusCodeKind::TransferStarted,
StatusCodeKind::TransferAboutToStart,
],
)
.await?;
let mut buffer = Vec::with_capacity(1024);
conn.read_to_end(&mut buffer).await?;
self.parse_reply_expecting(vec![StatusCodeKind::RequestActionCompleted])
.await?;
let text = String::from_utf8(buffer).map_err(|_| {
crate::error::Error::SerializationFailed(
"Invalid ASCII returned on server directory name listing.".to_string(),
)
})?;
Ok(text.lines().map(|line| line.to_owned()).collect())
}
/// Store a new file on a provided path and name.
pub async fn store<B: AsRef<[u8]>>(
&mut self,
path: &str,
data: B,
) -> Result<(), crate::error::Error> {
// Scope connection so it drops before reading server reply.
{
let mut conn = self.get_data_connection().await?;
self.write_unary_command_expecting(
"STOR",
path,
vec![
StatusCodeKind::TransferStarted,
StatusCodeKind::TransferAboutToStart,
],
)
.await?;
conn.write_all(data.as_ref()).await?;
}
self.parse_reply_expecting(vec![StatusCodeKind::RequestActionCompleted])
.await?;
Ok(())
}
/// Store a new file on a provided path using a random unique name.
pub async fn store_unique<B: AsRef<[u8]>>(
&mut self,
data: B,
) -> Result<String, crate::error::Error> {
// Scope connection so it drops before reading server reply.
{
let mut conn = self.get_data_connection().await?;
self.write_command_expecting(
"STOU",
vec![
StatusCodeKind::TransferStarted,
StatusCodeKind::TransferAboutToStart,
],
)
.await?;
conn.write_all(data.as_ref()).await?;
}
let reply = self
.parse_reply_expecting(vec![StatusCodeKind::RequestActionCompleted])
.await?;
Ok(reply.message)
}
/// Append to a existing file or a create a new one.
pub async fn append<B: AsRef<[u8]>>(
&mut self,
path: &str,
data: B,
) -> Result<(), crate::error::Error> {
// Scope connection so it drops before reading server reply.
{
let mut conn = self.get_data_connection().await?;
self.write_unary_command_expecting(
"APPE",
path,
vec![
StatusCodeKind::TransferStarted,
StatusCodeKind::TransferAboutToStart,
],
)
.await?;
conn.write_all(data.as_ref()).await?;
}
self.parse_reply_expecting(vec![
StatusCodeKind::RequestActionCompleted,
StatusCodeKind::RequestFileActionCompleted,
])
.await?;
Ok(())
}
/// Restart a file transfer. Unimplemented.
pub fn restart(&mut self) -> Result<(), crate::error::Error> {
unimplemented!();
}
/// Abort a file transfer. Unimplemented.
pub fn abort(&mut self) -> Result<(), crate::error::Error> {
unimplemented!();
}
/// Preallocate space on the server. Unimplemented.
pub fn allocate(
&mut self,
_logical_size: usize,
_logical_page_size: Option<usize>,
) -> Result<(), crate::error::Error> {
unimplemented!();
}
/// Move a file from a path to another, essentially renaming it.
pub async fn rename_file(
&mut self,
path_from: &str,
path_to: &str,
) -> Result<(), crate::error::Error> {
self.write_unary_command_expecting(
"RNFR",
path_from,
vec![StatusCodeKind::RequestActionPending],
)
.await?;
self.write_unary_command_expecting(
"RNTO",
path_to,
vec![StatusCodeKind::RequestFileActionCompleted],
)
.await?;
Ok(())
}
/// Remove an existing directory.
pub async fn remove_directory(&mut self, dir_path: &str) -> Result<(), crate::error::Error> {
self.write_unary_command_expecting(
"RMD",
dir_path,
vec![StatusCodeKind::RequestFileActionCompleted],
)
.await?;
Ok(())
}
/// Make a new directory.
pub async fn make_directory(&mut self, dir_path: &str) -> Result<(), crate::error::Error> {
self.write_unary_command_expecting("MKD", dir_path, vec![StatusCodeKind::PathCreated])
.await?;
Ok(())
}
/// Get the current working directory.
pub async fn pwd(&mut self) -> Result<String, crate::error::Error> {
let response = self
.write_command_expecting("PWD", vec![StatusCodeKind::PathCreated])
.await?;
Ok(response.message)
}
/// This command is used by the server to provide services
/// specific to his system that are essential to file transfer
/// but not sufficiently universal to be included as commands in
/// the protocol.
///
/// The nature of these services and the
/// specification of their syntax can be stated in a reply to
/// the HELP SITE command.
///
/// Extracted from RFC959.
pub async fn site_parameters(&mut self) -> Result<String, crate::error::Error> {
let response = self
.write_command_expecting(
"SITE",
vec![StatusCodeKind::Ok, StatusCodeKind::FeatureNotImplemented],
)
.await?;
Ok(response.message)
}
/// Get the type of operating system on the server.
pub async fn system(&mut self) -> Result<String, crate::error::Error> {
let response = self
.write_command_expecting("SYST", vec![StatusCodeKind::NameSystemType])
.await?;
Ok(response.message)
}
/// Delete a file at a path.
pub async fn delete_file(&mut self, dir_path: &str) -> Result<(), crate::error::Error> {
self.write_unary_command_expecting(
"DELE",
dir_path,
vec![StatusCodeKind::RequestFileActionCompleted],
)
.await?;
Ok(())
}
/// Download a file at a path into a byte buffer.
pub async fn retrieve_file(&mut self, path: &str) -> Result<Vec<u8>, crate::error::Error> {
let mut conn = self.get_data_connection().await?;
self.write_unary_command_expecting(
"RETR",
path,
vec![
StatusCodeKind::TransferAboutToStart,
StatusCodeKind::TransferStarted,
],
)
.await?;
let mut buffer = Vec::with_capacity(1024);
conn.read_to_end(&mut buffer).await?;
self.parse_reply_expecting(vec![StatusCodeKind::RequestActionCompleted])
.await?;
Ok(buffer)
}
/// Acquire the data connection using the current ClientMode.
pub async fn get_data_connection(&mut self) -> Result<TcpStream, crate::error::Error> {
match self.mode {
ClientMode::Active => unimplemented!(),
ClientMode::Passive => self.passive_mode_connection().await,
ClientMode::ExtendedPassive => self.extended_passive_mode_connection().await,
}
}
/// Create a extended passive mode connection.
pub async fn extended_passive_mode_connection(
&mut self,
) -> Result<TcpStream, crate::error::Error> {
let response = self
.write_command_expecting("EPSV", vec![StatusCodeKind::EnteredExtendedPassiveMode])
.await?;
let socket = self.decode_extended_passive_mode_socket(&response.message)?;
Ok(TcpStream::connect(socket).await?)
}
/// Create a passive mode connection.
pub async fn passive_mode_connection(&mut self) -> Result<TcpStream, crate::error::Error> {
let response = self
.write_command_expecting("PASV", vec![StatusCodeKind::EnteredPassiveMode])
.await?;
let socket = self.decode_passive_mode_ip(&response.message)?;
Ok(TcpStream::connect(socket).await?)
}
/// Write a command with one argument to the server expecting a list of positive status codes.
pub async fn write_unary_command_expecting(
&mut self,
cmd: &str,
arg: &str,
valid_statuses: Vec<StatusCodeKind>,
) -> Result<ServerResponse, crate::error::Error> {
self.write_unary_command(cmd, arg).await?;
self.parse_reply_expecting(valid_statuses).await
}
/// Write a command with one argument to the server.
pub async fn write_unary_command(
&mut self,
cmd: &str,
arg: &str,
) -> Result<(), crate::error::Error> {
let text = format!("{} {}\r\n", cmd, arg);
self.stream.get_mut().write_all(text.as_bytes()).await?;
Ok(())
}
/// Write a command to the server expecting a list of positive status codes.
pub async fn write_command_expecting(
&mut self,
cmd: &str,
valid_statuses: Vec<StatusCodeKind>,
) -> Result<ServerResponse, crate::error::Error> {
self.write_command(cmd).await?;
self.parse_reply_expecting(valid_statuses).await
}
/// Write a command to the server.
pub async fn write_command(&mut self, cmd: &str) -> Result<(), crate::error::Error> {
let text = format!("{}\r\n", cmd);
self.stream.get_mut().write_all(text.as_bytes()).await?;
Ok(())
}
/// Parse the server reply into a ServerResponse expecting a list of status codes.
pub async fn parse_reply_expecting(
&mut self,
valid_statuses: Vec<StatusCodeKind>,
) -> Result<ServerResponse, crate::error::Error> {
let response = self.parse_reply().await?;
let is_expected_status = valid_statuses.contains(&response.status_code.kind);
// We are a bit liberal on what we accept.
let is_positive_status = response.status_code.is_valid();
warn!(
"Unexpected positive status was accepted: {:?}",
response.status_code
);
if is_expected_status || is_positive_status {
Ok(response)
} else {
Err(crate::error::Error::UnexpectedStatusCode(
response.summarize_error(valid_statuses),
))
}
}
/// Parse the server reply into a ServerResponse.
pub async fn parse_reply(&mut self) -> Result<ServerResponse, crate::error::Error> {
self.buffer.clear();
self.stream.read_line(&mut self.buffer).await?;
Ok(ServerResponse::parse(&self.buffer))
}
/// Read the server reply as a raw string.
pub async fn read_reply(&mut self) -> Result<String, crate::error::Error> {
self.buffer.clear();
self.stream.read_line(&mut self.buffer).await?;
Ok(self.buffer.clone())
}
fn decode_passive_mode_ip(
&self,
message: &str,
) -> Result<std::net::SocketAddrV4, crate::error::Error> {
let first_bracket = message.find('(');
let second_bracket = message.find(')');
let cant_parse_error = || {
crate::error::Error::InvalidSocketPassiveMode(format!(
"Cannot parse socket sent from server for passive mode: {}.",
message
))
};
match (first_bracket, second_bracket) {
(Some(start), Some(end)) => {
// We are dealing with ASCII strings only on this point, so +1 is okay.
let nums: Vec<u8> = message[start + 1..end]
.split(',')
// Try to parse all digits between ','
.flat_map(|val| val.parse())
.collect();
if nums.len() < 4 {
Err(cant_parse_error())
} else {
let ip = std::net::Ipv4Addr::new(nums[0], nums[1], nums[2], nums[3]);
Ok(std::net::SocketAddrV4::new(
ip,
256 * nums[4] as u16 + nums[5] as u16,
))
}
}
_ => Err(cant_parse_error()),
}
}
fn decode_extended_passive_mode_socket(
&self,
response: &str,
) -> Result<std::net::SocketAddr, crate::error::Error> {
let first_delimiter = response.find("|||");
let second_delimiter = response.rfind('|');
let cant_parse_error = || {
crate::error::Error::InvalidSocketPassiveMode(format!(
"Cannot parse socket sent from server for passive mode: {}.",
response
))
};
match (first_delimiter, second_delimiter) {
(Some(start), Some(end)) => {
let port: u16 = response[start + 3..end]
.parse()
.map_err(move |_| cant_parse_error())?;
let ip = self
.stream
.get_ref()
.peer_addr()
.map_err(move |_| cant_parse_error())?
.ip();
Ok(std::net::SocketAddr::new(ip, port))
}
_ => Err(cant_parse_error()),
}
}
}
|
// Copyright 2021 Contributors to the Parsec project.
// SPDX-License-Identifier: Apache-2.0
//! PKCS11 Token info and associated flags
use crate::error::{Error, Result};
use crate::string_from_blank_padded;
use crate::types::convert_utc_time;
use crate::types::{UtcTime, Version};
use bitflags::bitflags;
use cryptoki_sys::*;
use std::convert::TryFrom;
use std::fmt::Debug;
bitflags! {
/// Collection of flags defined for [`CK_TOKEN_INFO`]
struct TokenInfoFlags: CK_FLAGS {
const RNG = CKF_RNG;
const WRITE_PROTECTED = CKF_WRITE_PROTECTED;
const LOGIN_REQUIRED = CKF_LOGIN_REQUIRED;
const USER_PIN_INITIALIZED = CKF_USER_PIN_INITIALIZED;
const RESTORE_KEY_NOT_NEEDED = CKF_RESTORE_KEY_NOT_NEEDED;
const CLOCK_ON_TOKEN = CKF_CLOCK_ON_TOKEN;
const PROTECTED_AUTHENTICATION_PATH = CKF_PROTECTED_AUTHENTICATION_PATH;
const DUAL_CRYPTO_OPERATIONS = CKF_DUAL_CRYPTO_OPERATIONS;
const TOKEN_INITIALIZED = CKF_TOKEN_INITIALIZED;
const SECONDARY_AUTHENTICATION = CKF_SECONDARY_AUTHENTICATION;
const USER_PIN_COUNT_LOW = CKF_USER_PIN_COUNT_LOW;
const USER_PIN_FINAL_TRY = CKF_USER_PIN_FINAL_TRY;
const USER_PIN_LOCKED = CKF_USER_PIN_LOCKED;
const USER_PIN_TO_BE_CHANGED = CKF_USER_PIN_TO_BE_CHANGED;
const SO_PIN_COUNT_LOW = CKF_SO_PIN_COUNT_LOW;
const SO_PIN_FINAL_TRY = CKF_SO_PIN_FINAL_TRY;
const SO_PIN_LOCKED = CKF_SO_PIN_LOCKED;
const SO_PIN_TO_BE_CHANGED = CKF_SO_PIN_TO_BE_CHANGED;
const ERROR_STATE = CKF_ERROR_STATE;
}
}
#[derive(Debug, Clone, Copy)]
/// A limiting value for the token that may or may not take an explicit value
pub enum Limit {
/// There is an explicit value for this limit
Max(u64),
/// The token does not provide information about this limit
Unavailable,
/// The limit is "effectively infinite" and may be treated as such
Infinite,
}
/// Information about a token
#[derive(Debug, Clone)]
pub struct TokenInfo {
// The following four strings are limited in size based on
// the orignating struct definition. Sizes are in *bytes*
// but UTF-8 data may represent fewer characters.
// Original buffers were space (0x20) padded.
label: String, // len <= 32 bytes
manufacturer_id: String, // len <= 32 bytes
model: String, // len <= 16 bytes
serial_number: String, // len <= 16 bytes
flags: TokenInfoFlags,
max_session_count: Limit,
session_count: Option<u64>,
max_rw_session_count: Limit,
rw_session_count: Option<u64>,
max_pin_len: usize,
min_pin_len: usize,
total_public_memory: Option<usize>,
free_public_memory: Option<usize>,
total_private_memory: Option<usize>,
free_private_memory: Option<usize>,
hardware_version: Version,
firmware_version: Version,
utc_time: Option<UtcTime>,
}
trait MaybeUnavailable: Sized {
fn maybe_unavailable(value: CK_ULONG) -> Option<Self>;
}
impl MaybeUnavailable for usize {
fn maybe_unavailable(value: CK_ULONG) -> Option<usize> {
if value == CK_UNAVAILABLE_INFORMATION {
None
} else {
Some(value as usize)
}
}
}
impl MaybeUnavailable for u64 {
fn maybe_unavailable(value: CK_ULONG) -> Option<u64> {
if value == CK_UNAVAILABLE_INFORMATION {
None
} else {
// Must have cast for when ulong is 32 bits
// Must have lint suppression when ulong is 64 bits
#[allow(trivial_numeric_casts)]
Some(value as u64)
}
}
}
/// Flattens both `Infinite` and `Unavailable` to `None`,
impl From<Limit> for Option<u64> {
fn from(limit: Limit) -> Self {
match limit {
Limit::Unavailable | Limit::Infinite => None,
Limit::Max(n) => Some(n),
}
}
}
fn maybe_unlimited(value: CK_ULONG) -> Limit {
match value {
CK_UNAVAILABLE_INFORMATION => Limit::Unavailable,
CK_EFFECTIVELY_INFINITE => Limit::Infinite,
// Must have cast for when ulong is 32 bits
// Must have lint suppression when ulong is 64 bits
#[allow(trivial_numeric_casts)]
_ => Limit::Max(value as u64),
}
}
impl TokenInfo {
/// An application-defined label, assigned during token initialization
///
/// **[Conformance](crate#conformance-notes):**
/// This string is maximally 32 bytes (*not* chars) as UTF-8
pub fn label(&self) -> &str {
&self.label
}
/// The ID of the device manufacturer
///
/// **[Conformance](crate#conformance-notes):**
/// This string is maximally 32 bytes (*not* chars) as UTF-8
pub fn manufacturer_id(&self) -> &str {
&self.manufacturer_id
}
/// The model of the device
///
/// **[Conformance](crate#conformance-notes):**
/// This string is maximally 16 bytes (*not* chars) as UTF-8
pub fn model(&self) -> &str {
&self.model
}
/// The character-string serial number of the device
///
/// **[Conformance](crate#conformance-notes):**
/// This string is maximally 16 bytes (*not* chars) as UTF-8
pub fn serial_number(&self) -> &str {
&self.serial_number
}
/// True if the token has its own random number generator
pub fn rng(&self) -> bool {
self.flags.contains(TokenInfoFlags::RNG)
}
/// True if the token is write-protected
///
/// **[Conformance](crate#conformance-notes):**
/// Exactly what this value means is determined by the application. An
/// application may be unable to perform certain actions on a write-
/// protected token. These actions can include any of the following (non-
/// exhaustive):
/// * Creating/modifying/deleting any object on the token
/// * Creating/modifying/deleting a token object on the token
/// * Changing the Security Officer's PIN
/// * Changing the normal user's PIN
///
/// The token may change its write-protected status depending on the
/// session state to implement its object management policy. For instance,
/// the token may report write-protection unless the session state is R/W
/// SO or R/W User to implement a policy that does not allow any objects,
/// public or private, to be created, modified, or deleted unless the user
/// has successfully called [`Session::login`](crate::session::Session::login).
pub fn write_protected(&self) -> bool {
self.flags.contains(TokenInfoFlags::WRITE_PROTECTED)
}
/// True if there are some cryptographic functions that a user *must* be
/// logged in to perform
pub fn login_required(&self) -> bool {
self.flags.contains(TokenInfoFlags::LOGIN_REQUIRED)
}
/// True of the normal user's PIN has been initialized
pub fn user_pin_initialized(&self) -> bool {
self.flags.contains(TokenInfoFlags::USER_PIN_INITIALIZED)
}
/// True if a successful save of a session's cryptographic operations state
/// *always* contains all keys needed to restore the state of the session.
pub fn restore_key_not_needed(&self) -> bool {
self.flags.contains(TokenInfoFlags::RESTORE_KEY_NOT_NEEDED)
}
/// True if the token has its own hardware clock
pub fn clock_on_token(&self) -> bool {
self.flags.contains(TokenInfoFlags::CLOCK_ON_TOKEN)
}
/// True if the token has a "protected authentication path" whereby a user
/// can log into the token without passing a PIN
pub fn protected_authentication_path(&self) -> bool {
self.flags
.contains(TokenInfoFlags::PROTECTED_AUTHENTICATION_PATH)
}
/// True if a single session with the token can perform dual cryptographic
/// operations
// TODO: Requires Session callbacks to access
// * digest_encrypt_update
// * decrypt_digest_update
// * sign_encrypt_update
// * decrypt_verify_update
pub fn dual_crypto_operations(&self) -> bool {
self.flags.contains(TokenInfoFlags::DUAL_CRYPTO_OPERATIONS)
}
/// True if the token has been initialized with
/// [`Pkcs11::init_token](crate::context::Pkcs11::init_token) or an
/// equivalent mechanism outside the scope of the PKCS#11 standard
///
/// **[Conformance](crate#conformance-notes):**
/// Calling [`Pkcs11::init_token`](crate::context::Pkcs11::init_token) when
/// this flag is set will cause the token to be reinitialized.
pub fn token_initialized(&self) -> bool {
self.flags.contains(TokenInfoFlags::TOKEN_INITIALIZED)
}
/// True if the token supports secondary authentication for private key
/// objects
/// **[Conformance](crate#conformance-notes):**
/// This field is deprecated and new providers *must not* set it. I.e., this function must always return `false`.
pub fn secondary_authentication(&self) -> bool {
self.flags
.contains(TokenInfoFlags::SECONDARY_AUTHENTICATION)
}
/// True if an incorrect user login PIN has been entered at least once
/// since the last successful authentication
///
/// **[Conformance](crate#conformance-notes):**
/// This value may be set to always be false if the token either does not
/// support the functionality or will not reveal the information because of
/// its security policy.
pub fn user_pin_count_low(&self) -> bool {
self.flags.contains(TokenInfoFlags::USER_PIN_COUNT_LOW)
}
/// True if supplying an incorrect user PIN will cause it to become locked
///
/// **[Conformance](crate#conformance-notes):**
/// This value may be set to always be false if the token either does not
/// support the functionality or will not reveal the information because of
/// its security policy.
pub fn user_pin_final_try(&self) -> bool {
self.flags.contains(TokenInfoFlags::USER_PIN_FINAL_TRY)
}
/// True if the user PIN has been locked; user login to the token is not
/// possible
pub fn user_pin_locked(&self) -> bool {
self.flags.contains(TokenInfoFlags::USER_PIN_LOCKED)
}
/// True if the user PIN value is the default value set by the token
/// initialization or manufacturing, or the PIN has been expired by the
/// card
///
/// **[Conformance](crate#conformance-notes):**
/// This may be always false if the token either does not support the
/// functionality or will not reveal the information because of its
/// security policy.
///
/// If a PIN is set to the default value or has expired, this function
/// returns `true`. When true, logging in with a PIN will succeed, but only
/// the [`Session::set_pin`][crate::session::Session::set_pin] function can
/// be called. Calling any other function that required the user to be
/// logged in will cause [`PinExpired`][crate::error::RvError::PinExpired]
/// to be returned until
/// [`Session::set_pin`][crate::session::Session::set_pin] is called
/// successfully.
pub fn user_pin_to_be_changed(&self) -> bool {
self.flags.contains(TokenInfoFlags::USER_PIN_TO_BE_CHANGED)
}
/// True if an incorrect Security Officer login PIN has been entered at least once since
/// the last successful authentication
///
/// **[Conformance](crate#conformance-notes):**
/// This value may be set to always be false if the token either does not
/// support the functionality or will not reveal the information because of
/// its security policy.
pub fn so_pin_count_low(&self) -> bool {
self.flags.contains(TokenInfoFlags::SO_PIN_COUNT_LOW)
}
/// True if supplying an incorrect Security Officer PIN will cause it to become locked
///
/// **[Conformance](crate#conformance-notes):**
/// This value may be set to always be false if the token either does not
/// support the functionality or will not reveal the information because of
/// its security policy.
pub fn so_pin_final_try(&self) -> bool {
self.flags.contains(TokenInfoFlags::SO_PIN_FINAL_TRY)
}
/// True if the Security Officer PIN has been locked; Security Officer login to the token is not
/// possible
pub fn so_pin_locked(&self) -> bool {
self.flags.contains(TokenInfoFlags::SO_PIN_LOCKED)
}
/// True if the Security Officer PIN value is the default value set by the token
/// initialization or manufacturing, or the PIN has been expired by the card
///
/// **[Conformance](crate#conformance-notes):**
/// This may be always false if the token either does not support the
/// functionality or will not reveal the information because of its security
/// policy.
///
/// If a PIN is set to the default value or has expired, this function
/// returns `true`. When true, logging in with a PIN will succeed, but only
/// the [`Session::set_pin`][crate::session::Session::set_pin] function can
/// be called. Calling any other function that required the user to be
/// logged in will cause [`PinExpired`][crate::error::RvError::PinExpired]
/// to be returned until
/// [`Session::set_pin`][crate::session::Session::set_pin] is called
/// successfully.
pub fn so_pin_to_be_changed(&self) -> bool {
self.flags.contains(TokenInfoFlags::SO_PIN_TO_BE_CHANGED)
}
/// True if the token failed a FIPS 140-2 self-test and entered an error state
pub fn error_state(&self) -> bool {
self.flags.contains(TokenInfoFlags::ERROR_STATE)
}
/// The maximum number of sessions that can be opened with the token at one
/// time by a single application.
pub fn max_session_count(&self) -> Limit {
self.max_session_count
}
/// The number of sessions this application currently has open with the
/// token
pub fn session_count(&self) -> Option<u64> {
self.session_count
}
/// The maximum number of read/write sessions that can be opened with the
/// token at one time by a single application.
pub fn max_rw_session_count(&self) -> Limit {
self.max_rw_session_count
}
/// The number of read/write sessions this application currently has open
/// with the token
pub fn rw_session_count(&self) -> Option<u64> {
self.rw_session_count
}
/// The maximum length in bytes of the PIN
pub fn max_pin_length(&self) -> usize {
self.max_pin_len
}
/// The minimum length in bytes of the PIN
pub fn min_pin_length(&self) -> usize {
self.min_pin_len
}
/// The total amount of memory on the token (in bytes) in which public
/// objects may be stored
/// Returns `None` if this information is unavailable
pub fn total_public_memory(&self) -> Option<usize> {
self.total_public_memory
}
/// The amount of free (unused) emmeory on the token (in bytes) for public
/// objects
/// Returns `None` if this information is unavailable
pub fn free_public_memory(&self) -> Option<usize> {
self.free_public_memory
}
/// The total amount of memory on the token (in bytes) in which private
/// objects may be stored
/// Returns `None` if this information is unavailable
pub fn total_private_memory(&self) -> Option<usize> {
self.total_private_memory
}
/// The amount of free (unused) emmeory on the token (in bytes) for private
/// objects
/// Returns `None` if this information is unavailable
pub fn free_private_memory(&self) -> Option<usize> {
self.free_private_memory
}
/// The version number of the hardware
pub fn hardware_version(&self) -> Version {
self.hardware_version
}
/// The version number of the firmware
pub fn firmware_version(&self) -> Version {
self.firmware_version
}
/// The current UTC datetime reported by the token
///
/// Returns `None` if the token is not equipped with a clock (i.e.,
/// `self.clock_on_token() == false`)
///
/// **[Conformance](crate#conformance-notes):**
/// The string representation of the datetime from the token is only
/// required to be parsable as a string of ASCII digits. No additional
/// structure (e.g., months numbered from 0 or from 1) is defined.
pub fn utc_time(&self) -> Option<UtcTime> {
self.utc_time
}
}
#[doc(hidden)]
impl TryFrom<CK_TOKEN_INFO> for TokenInfo {
type Error = Error;
fn try_from(val: CK_TOKEN_INFO) -> Result<Self> {
let flags = TokenInfoFlags::from_bits_truncate(val.flags);
let utc_time = if flags.contains(TokenInfoFlags::CLOCK_ON_TOKEN) {
Some(convert_utc_time(val.utcTime)?)
} else {
None
};
Ok(Self {
label: string_from_blank_padded(&val.label),
manufacturer_id: string_from_blank_padded(&val.manufacturerID),
model: string_from_blank_padded(&val.model),
serial_number: string_from_blank_padded(&val.serialNumber),
flags,
max_session_count: maybe_unlimited(val.ulMaxSessionCount),
session_count: u64::maybe_unavailable(val.ulSessionCount),
max_rw_session_count: maybe_unlimited(val.ulMaxRwSessionCount),
rw_session_count: u64::maybe_unavailable(val.ulRwSessionCount),
max_pin_len: val.ulMaxPinLen as usize,
min_pin_len: val.ulMinPinLen as usize,
total_public_memory: usize::maybe_unavailable(val.ulTotalPublicMemory),
free_public_memory: usize::maybe_unavailable(val.ulFreePublicMemory),
total_private_memory: usize::maybe_unavailable(val.ulTotalPrivateMemory),
free_private_memory: usize::maybe_unavailable(val.ulFreePrivateMemory),
hardware_version: val.hardwareVersion.into(),
firmware_version: val.firmwareVersion.into(),
utc_time,
})
}
}
#[cfg(test)]
mod test {
use super::{Limit, TokenInfo, TokenInfoFlags};
use crate::types::{UtcTime, Version};
#[test]
fn debug_flags_all() {
let expected = "\
RNG | WRITE_PROTECTED | LOGIN_REQUIRED | USER_PIN_INITIALIZED | \
RESTORE_KEY_NOT_NEEDED | CLOCK_ON_TOKEN | PROTECTED_AUTHENTICATION_PATH | \
DUAL_CRYPTO_OPERATIONS | TOKEN_INITIALIZED | SECONDARY_AUTHENTICATION | \
USER_PIN_COUNT_LOW | USER_PIN_FINAL_TRY | USER_PIN_LOCKED | \
USER_PIN_TO_BE_CHANGED | SO_PIN_COUNT_LOW | SO_PIN_FINAL_TRY | SO_PIN_LOCKED | \
SO_PIN_TO_BE_CHANGED | ERROR_STATE";
let all = TokenInfoFlags::all();
let observed = format!("{:#?}", all);
assert_eq!(observed, expected);
}
#[test]
fn debug_info() {
let info = TokenInfo {
label: String::from("Token Label"),
manufacturer_id: String::from("Manufacturer ID"),
model: String::from("Token Model"),
serial_number: String::from("Serial Number"),
flags: TokenInfoFlags::empty(),
max_session_count: Limit::Max(100), // max == 100
session_count: None, // unavailable
max_rw_session_count: Limit::Infinite, // max == infinite
rw_session_count: Some(1),
max_pin_len: 16,
min_pin_len: 4,
total_public_memory: Some(32 << 30), // 32GiB
free_public_memory: Some(1234567890),
total_private_memory: None, // unavailable
free_private_memory: None, // unavailable
hardware_version: Version::new(0, 255),
firmware_version: Version::new(255, 0),
utc_time: Some(UtcTime {
year: 1970,
month: 1,
day: 1,
hour: 0,
minute: 0,
second: 0,
}),
};
let expected = r#"TokenInfo {
label: "Token Label",
manufacturer_id: "Manufacturer ID",
model: "Token Model",
serial_number: "Serial Number",
flags: (empty),
max_session_count: Max(
100,
),
session_count: None,
max_rw_session_count: Infinite,
rw_session_count: Some(
1,
),
max_pin_len: 16,
min_pin_len: 4,
total_public_memory: Some(
34359738368,
),
free_public_memory: Some(
1234567890,
),
total_private_memory: None,
free_private_memory: None,
hardware_version: Version {
major: 0,
minor: 255,
},
firmware_version: Version {
major: 255,
minor: 0,
},
utc_time: Some(
UtcTime {
year: 1970,
month: 1,
day: 1,
hour: 0,
minute: 0,
second: 0,
},
),
}"#;
let observed = format!("{:#?}", info);
assert_eq!(observed, expected);
}
}
|
#![cfg_attr(all(nightly, test), feature(test))]
mod atomic;
pub mod mpsc;
pub mod mpsc_list;
pub mod mpsc_list_v1;
pub mod spmc;
pub mod spsc;
#[cfg(test)]
mod test_queue {
pub trait ScBlockPop<T> {
fn block_pop(&self) -> T;
}
}
|
use std::collections::{HashMap, HashSet};
type Coordinate = (isize, isize);
#[derive(Debug)]
enum Dir {
Up,
Down,
Left,
Right,
}
impl Dir {
pub fn delta(&self) -> Coordinate {
match self {
Dir::Up => (0, 1),
Dir::Down => (0, -1),
Dir::Left => (-1, 0),
Dir::Right => (1, 0),
}
}
}
// in real world, we'd use TryFrom, but no malformed inputs here.
impl From<char> for Dir {
fn from(c: char) -> Self {
match c {
'U' => Self::Up,
'D' => Self::Down,
'L' => Self::Left,
'R' => Self::Right,
_ => panic!("non-supported direction"),
}
}
}
#[derive(Debug)]
struct Step {
dir: Dir,
len: usize,
}
impl From<&str> for Step {
fn from(s: &str) -> Self {
let dir = s.chars().nth(0).unwrap().into();
let len = s[1..].parse().unwrap();
Self { dir, len }
}
}
fn path(route: &[Step]) -> HashMap<Coordinate, isize> {
let mut map = HashMap::new();
let mut len = 1;
let (mut x, mut y) = (0, 0);
for step in route {
let (dx, dy) = step.dir.delta();
for _ in 0..step.len {
x += dx;
y += dy;
*map.entry((x, y)).or_insert(0) = len;
len += 1;
}
}
map
}
fn manhattan_distance(coord: Coordinate) -> isize {
coord.0.abs() + coord.1.abs()
}
fn solve_01(routes: &[Vec<Step>]) -> isize {
let path_one = path(&routes[0]);
let path_two = path(&routes[1]);
let set_one: HashSet<_> = path_one.keys().collect();
let set_two: HashSet<_> = path_two.keys().collect();
let intersections = set_one.intersection(&set_two);
intersections
.map(|x| manhattan_distance(**x))
.min()
.unwrap()
}
fn solve_02(routes: &[Vec<Step>]) -> isize {
let path_one = path(&routes[0]);
let path_two = path(&routes[1]);
let set_one: HashSet<_> = path_one.keys().collect();
let set_two: HashSet<_> = path_two.keys().collect();
let intersections = set_one.intersection(&set_two);
intersections
.map(|x| path_one.get(*x).unwrap() + path_two.get(*x).unwrap())
.min()
.unwrap()
}
fn parse(input: &str) -> Vec<Vec<Step>> {
input
.lines()
.map(|line| line.trim().split(',').map(Step::from).collect())
.collect()
}
pub fn solve(input: &str) {
let instructions = parse(input);
println!("part one: {}", solve_01(&instructions));
println!("part two: {}", solve_02(&instructions));
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn part_one() {
let input = parse(
"R98,U47,R26,D63,R33,U87,L62,D20,R33,U53,R51
U98,R91,D20,R16,D67,R40,U7,R15,U6,R7",
);
let res = solve_01(&input);
assert_eq!(res, 135);
}
#[test]
fn part_two() {
let input = parse(
"R98,U47,R26,D63,R33,U87,L62,D20,R33,U53,R51
U98,R91,D20,R16,D67,R40,U7,R15,U6,R7",
);
let res = solve_02(&input);
assert_eq!(res, 410);
}
}
|
use proc_macro::TokenStream;
use quote::{format_ident, quote};
use syn::punctuated::Punctuated;
use syn::{parse_macro_input, Error, FnArg, ItemFn, LitStr, Pat, Token};
/// Creates an inline hook at a C# method.
///
/// # Panics
///
/// * `install` will panic if the class or method was not found.
/// * `original` will panic if the hook has not yet been installed.
///
/// # Examples
///
/// ```no_run
/// use quest_hook::inline_hook::hook;
/// use quest_hook::libil2cpp::Il2CppObject;
/// use log::info;
///
/// #[hook("", "MainSettingsModelSO", "OnEnable")]
/// fn on_enable(this: &Il2CppObject) {
/// info!("MainSettingsModelSO.OnEnable was called!");
///
/// on_enable.original(this); // Call the original C# method
/// }
///
/// #[no_mangle]
/// pub extern "C" fn load() {
/// info!("Installing hooks!");
///
/// on_enable.install(); // Install the hook
///
/// info!("Installed hooks!");
/// }
/// ```
#[proc_macro_attribute]
pub fn hook(attr: TokenStream, item: TokenStream) -> TokenStream {
let punctuated_args =
parse_macro_input!(attr with Punctuated<LitStr, Token![,]>::parse_separated_nonempty);
let input = parse_macro_input!(item as ItemFn);
match create_hook(punctuated_args, input) {
Ok(ts) => ts,
Err(err) => err.to_compile_error().into(),
}
}
fn create_hook(
punctuated_args: Punctuated<LitStr, Token![,]>,
input: ItemFn,
) -> Result<TokenStream, Error> {
let args: Vec<String> = punctuated_args.iter().map(LitStr::value).collect();
let (namespace, class, method) = match args.as_slice() {
[n, c, m] => (n, c, m),
_ => {
let msg = format!("Expected 3 arguments, found {}", args.len());
return Err(Error::new_spanned(punctuated_args, msg));
}
};
let ItemFn { sig, block, .. } = input;
let name = sig.ident;
let return_type = sig.output;
let hook_name = format_ident!("{}_hook", name);
let hook_args = sig.inputs;
let mut num_hook_args = 0;
for hook_arg in hook_args.iter() {
match match hook_arg {
FnArg::Typed(arg_type) => &*arg_type.pat,
FnArg::Receiver(_) => {
let msg = "Hook argument cannot be `self`";
return Err(Error::new_spanned(hook_arg, msg));
}
} {
// `il2cpp_class_get_method_from_name` does not count `this` in its argument count
Pat::Ident(pat_ident) if pat_ident.ident == "this" => {}
_ => num_hook_args += 1,
}
}
let hook_struct_name = format_ident!("{}_Struct", name);
let mut hook_args_untyped: Punctuated<Pat, Token![,]> = Punctuated::new();
for arg in &hook_args {
if let FnArg::Typed(arg) = arg {
hook_args_untyped.push((*arg.pat).clone());
}
}
let tokens = quote! {
pub extern "C" fn #hook_name ( #hook_args ) #return_type #block
#[allow(non_camel_case_types)]
struct #hook_struct_name {
original: ::std::sync::atomic::AtomicPtr<()>,
namespace: &'static str,
class_name: &'static str,
method_name: &'static str,
args_count: u32,
}
impl #hook_struct_name {
fn install(&self) {
let class = ::quest_hook::utils::find_class(self.namespace, self.class_name).expect("Class not found");
let method = class.find_method(self.method_name, self.args_count).expect("Method not found");
let mut temp = ::std::ptr::null_mut();
unsafe {
::quest_hook::inline_hook::A64HookFunction(
::std::mem::transmute::<unsafe extern "C" fn(), *mut ::std::ffi::c_void>(method.methodPointer.unwrap()),
::std::mem::transmute::<extern "C" fn( #hook_args ) #return_type, *mut ::std::ffi::c_void>( #hook_name ),
&mut temp,
);
self.original.store(
::std::mem::transmute::<*mut ::std::ffi::c_void, *mut ()>(temp),
::std::sync::atomic::Ordering::Relaxed
);
}
}
fn original(&self, #hook_args ) #return_type {
let ptr = self.original.load(::std::sync::atomic::Ordering::Relaxed);
let original = unsafe {
::std::mem::transmute::<*const (), Option<extern "C" fn( #hook_args ) #return_type >>(ptr)
};
(original.expect("Hook is not installed"))( #hook_args_untyped )
}
}
#[allow(non_upper_case_globals)]
static #name: #hook_struct_name = #hook_struct_name {
original: ::std::sync::atomic::AtomicPtr::new(::std::ptr::null_mut()),
namespace: #namespace,
class_name: #class,
method_name: #method,
args_count: #num_hook_args as u32
};
};
Ok(tokens.into())
}
|
#[doc = "Register `GTZC1_TZIC_IER1` reader"]
pub type R = crate::R<GTZC1_TZIC_IER1_SPEC>;
#[doc = "Register `GTZC1_TZIC_IER1` writer"]
pub type W = crate::W<GTZC1_TZIC_IER1_SPEC>;
#[doc = "Field `TIM2IE` reader - illegal access interrupt enable for TIM2"]
pub type TIM2IE_R = crate::BitReader;
#[doc = "Field `TIM2IE` writer - illegal access interrupt enable for TIM2"]
pub type TIM2IE_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `TIM3IE` reader - illegal access interrupt enable for TIM3"]
pub type TIM3IE_R = crate::BitReader;
#[doc = "Field `TIM3IE` writer - illegal access interrupt enable for TIM3"]
pub type TIM3IE_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `TIM4IE` reader - illegal access interrupt enable for TIM4"]
pub type TIM4IE_R = crate::BitReader;
#[doc = "Field `TIM4IE` writer - illegal access interrupt enable for TIM4"]
pub type TIM4IE_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `TIM5IE` reader - illegal access interrupt enable for TIM5"]
pub type TIM5IE_R = crate::BitReader;
#[doc = "Field `TIM5IE` writer - illegal access interrupt enable for TIM5"]
pub type TIM5IE_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `TIM6IE` reader - illegal access interrupt enable for TIM6"]
pub type TIM6IE_R = crate::BitReader;
#[doc = "Field `TIM6IE` writer - illegal access interrupt enable for TIM6"]
pub type TIM6IE_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `TIM7IE` reader - illegal access interrupt enable for TIM7"]
pub type TIM7IE_R = crate::BitReader;
#[doc = "Field `TIM7IE` writer - illegal access interrupt enable for TIM7"]
pub type TIM7IE_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `TIM12IE` reader - illegal access interrupt enable for TIM12"]
pub type TIM12IE_R = crate::BitReader;
#[doc = "Field `TIM12IE` writer - illegal access interrupt enable for TIM12"]
pub type TIM12IE_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `TIM13IE` reader - illegal access interrupt enable for TIM13"]
pub type TIM13IE_R = crate::BitReader;
#[doc = "Field `TIM13IE` writer - illegal access interrupt enable for TIM13"]
pub type TIM13IE_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `TIM14IE` reader - illegal access interrupt enable for TIM14"]
pub type TIM14IE_R = crate::BitReader;
#[doc = "Field `TIM14IE` writer - illegal access interrupt enable for TIM14"]
pub type TIM14IE_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `WWDGIE` reader - illegal access interrupt enable for WWDG"]
pub type WWDGIE_R = crate::BitReader;
#[doc = "Field `WWDGIE` writer - illegal access interrupt enable for WWDG"]
pub type WWDGIE_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `IWDGIE` reader - illegal access interrupt enable for IWDG"]
pub type IWDGIE_R = crate::BitReader;
#[doc = "Field `IWDGIE` writer - illegal access interrupt enable for IWDG"]
pub type IWDGIE_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `SPI2IE` reader - illegal access interrupt enable for SPI2"]
pub type SPI2IE_R = crate::BitReader;
#[doc = "Field `SPI2IE` writer - illegal access interrupt enable for SPI2"]
pub type SPI2IE_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `SPI3IE` reader - illegal access interrupt enable for SPI3"]
pub type SPI3IE_R = crate::BitReader;
#[doc = "Field `SPI3IE` writer - illegal access interrupt enable for SPI3"]
pub type SPI3IE_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `USART2IE` reader - illegal access interrupt enable for USART2"]
pub type USART2IE_R = crate::BitReader;
#[doc = "Field `USART2IE` writer - illegal access interrupt enable for USART2"]
pub type USART2IE_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `USART3IE` reader - illegal access interrupt enable for USART3"]
pub type USART3IE_R = crate::BitReader;
#[doc = "Field `USART3IE` writer - illegal access interrupt enable for USART3"]
pub type USART3IE_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `UART4IE` reader - illegal access interrupt enable for UART4"]
pub type UART4IE_R = crate::BitReader;
#[doc = "Field `UART4IE` writer - illegal access interrupt enable for UART4"]
pub type UART4IE_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `UART5IE` reader - illegal access interrupt enable for UART5"]
pub type UART5IE_R = crate::BitReader;
#[doc = "Field `UART5IE` writer - illegal access interrupt enable for UART5"]
pub type UART5IE_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `I2C1IE` reader - illegal access interrupt enable for I2C1"]
pub type I2C1IE_R = crate::BitReader;
#[doc = "Field `I2C1IE` writer - illegal access interrupt enable for I2C1"]
pub type I2C1IE_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `I2C2IE` reader - illegal access interrupt enable for I2C2"]
pub type I2C2IE_R = crate::BitReader;
#[doc = "Field `I2C2IE` writer - illegal access interrupt enable for I2C2"]
pub type I2C2IE_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `I3C1IE` reader - illegal access interrupt enable for I3C1"]
pub type I3C1IE_R = crate::BitReader;
#[doc = "Field `I3C1IE` writer - illegal access interrupt enable for I3C1"]
pub type I3C1IE_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `CRSIE` reader - illegal access interrupt enable for CRS"]
pub type CRSIE_R = crate::BitReader;
#[doc = "Field `CRSIE` writer - illegal access interrupt enable for CRS"]
pub type CRSIE_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `USART6IE` reader - illegal access interrupt enable for USART6"]
pub type USART6IE_R = crate::BitReader;
#[doc = "Field `USART6IE` writer - illegal access interrupt enable for USART6"]
pub type USART6IE_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `USART10IE` reader - illegal access interrupt enable for USART10"]
pub type USART10IE_R = crate::BitReader;
#[doc = "Field `USART10IE` writer - illegal access interrupt enable for USART10"]
pub type USART10IE_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `USART11IE` reader - illegal access interrupt enable for USART11"]
pub type USART11IE_R = crate::BitReader;
#[doc = "Field `USART11IE` writer - illegal access interrupt enable for USART11"]
pub type USART11IE_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `HDMICECIE` reader - illegal access interrupt enable for HDMICEC"]
pub type HDMICECIE_R = crate::BitReader;
#[doc = "Field `HDMICECIE` writer - illegal access interrupt enable for HDMICEC"]
pub type HDMICECIE_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `DAC1IE` reader - illegal access interrupt enable for DAC1"]
pub type DAC1IE_R = crate::BitReader;
#[doc = "Field `DAC1IE` writer - illegal access interrupt enable for DAC1"]
pub type DAC1IE_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `UART7IE` reader - illegal access interrupt enable for UART7"]
pub type UART7IE_R = crate::BitReader;
#[doc = "Field `UART7IE` writer - illegal access interrupt enable for UART7"]
pub type UART7IE_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `UART8IE` reader - illegal access interrupt enable for UART8"]
pub type UART8IE_R = crate::BitReader;
#[doc = "Field `UART8IE` writer - illegal access interrupt enable for UART8"]
pub type UART8IE_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `UART9IE` reader - illegal access interrupt enable for UART9"]
pub type UART9IE_R = crate::BitReader;
#[doc = "Field `UART9IE` writer - illegal access interrupt enable for UART9"]
pub type UART9IE_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `UART12IE` reader - illegal access interrupt enable for UART12"]
pub type UART12IE_R = crate::BitReader;
#[doc = "Field `UART12IE` writer - illegal access interrupt enable for UART12"]
pub type UART12IE_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `DTSIE` reader - illegal access interrupt enable for DTS"]
pub type DTSIE_R = crate::BitReader;
#[doc = "Field `DTSIE` writer - illegal access interrupt enable for DTS"]
pub type DTSIE_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `LPTIM2IE` reader - illegal access interrupt enable for LPTIM2"]
pub type LPTIM2IE_R = crate::BitReader;
#[doc = "Field `LPTIM2IE` writer - illegal access interrupt enable for LPTIM2"]
pub type LPTIM2IE_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
impl R {
#[doc = "Bit 0 - illegal access interrupt enable for TIM2"]
#[inline(always)]
pub fn tim2ie(&self) -> TIM2IE_R {
TIM2IE_R::new((self.bits & 1) != 0)
}
#[doc = "Bit 1 - illegal access interrupt enable for TIM3"]
#[inline(always)]
pub fn tim3ie(&self) -> TIM3IE_R {
TIM3IE_R::new(((self.bits >> 1) & 1) != 0)
}
#[doc = "Bit 2 - illegal access interrupt enable for TIM4"]
#[inline(always)]
pub fn tim4ie(&self) -> TIM4IE_R {
TIM4IE_R::new(((self.bits >> 2) & 1) != 0)
}
#[doc = "Bit 3 - illegal access interrupt enable for TIM5"]
#[inline(always)]
pub fn tim5ie(&self) -> TIM5IE_R {
TIM5IE_R::new(((self.bits >> 3) & 1) != 0)
}
#[doc = "Bit 4 - illegal access interrupt enable for TIM6"]
#[inline(always)]
pub fn tim6ie(&self) -> TIM6IE_R {
TIM6IE_R::new(((self.bits >> 4) & 1) != 0)
}
#[doc = "Bit 5 - illegal access interrupt enable for TIM7"]
#[inline(always)]
pub fn tim7ie(&self) -> TIM7IE_R {
TIM7IE_R::new(((self.bits >> 5) & 1) != 0)
}
#[doc = "Bit 6 - illegal access interrupt enable for TIM12"]
#[inline(always)]
pub fn tim12ie(&self) -> TIM12IE_R {
TIM12IE_R::new(((self.bits >> 6) & 1) != 0)
}
#[doc = "Bit 7 - illegal access interrupt enable for TIM13"]
#[inline(always)]
pub fn tim13ie(&self) -> TIM13IE_R {
TIM13IE_R::new(((self.bits >> 7) & 1) != 0)
}
#[doc = "Bit 8 - illegal access interrupt enable for TIM14"]
#[inline(always)]
pub fn tim14ie(&self) -> TIM14IE_R {
TIM14IE_R::new(((self.bits >> 8) & 1) != 0)
}
#[doc = "Bit 9 - illegal access interrupt enable for WWDG"]
#[inline(always)]
pub fn wwdgie(&self) -> WWDGIE_R {
WWDGIE_R::new(((self.bits >> 9) & 1) != 0)
}
#[doc = "Bit 10 - illegal access interrupt enable for IWDG"]
#[inline(always)]
pub fn iwdgie(&self) -> IWDGIE_R {
IWDGIE_R::new(((self.bits >> 10) & 1) != 0)
}
#[doc = "Bit 11 - illegal access interrupt enable for SPI2"]
#[inline(always)]
pub fn spi2ie(&self) -> SPI2IE_R {
SPI2IE_R::new(((self.bits >> 11) & 1) != 0)
}
#[doc = "Bit 12 - illegal access interrupt enable for SPI3"]
#[inline(always)]
pub fn spi3ie(&self) -> SPI3IE_R {
SPI3IE_R::new(((self.bits >> 12) & 1) != 0)
}
#[doc = "Bit 13 - illegal access interrupt enable for USART2"]
#[inline(always)]
pub fn usart2ie(&self) -> USART2IE_R {
USART2IE_R::new(((self.bits >> 13) & 1) != 0)
}
#[doc = "Bit 14 - illegal access interrupt enable for USART3"]
#[inline(always)]
pub fn usart3ie(&self) -> USART3IE_R {
USART3IE_R::new(((self.bits >> 14) & 1) != 0)
}
#[doc = "Bit 15 - illegal access interrupt enable for UART4"]
#[inline(always)]
pub fn uart4ie(&self) -> UART4IE_R {
UART4IE_R::new(((self.bits >> 15) & 1) != 0)
}
#[doc = "Bit 16 - illegal access interrupt enable for UART5"]
#[inline(always)]
pub fn uart5ie(&self) -> UART5IE_R {
UART5IE_R::new(((self.bits >> 16) & 1) != 0)
}
#[doc = "Bit 17 - illegal access interrupt enable for I2C1"]
#[inline(always)]
pub fn i2c1ie(&self) -> I2C1IE_R {
I2C1IE_R::new(((self.bits >> 17) & 1) != 0)
}
#[doc = "Bit 18 - illegal access interrupt enable for I2C2"]
#[inline(always)]
pub fn i2c2ie(&self) -> I2C2IE_R {
I2C2IE_R::new(((self.bits >> 18) & 1) != 0)
}
#[doc = "Bit 19 - illegal access interrupt enable for I3C1"]
#[inline(always)]
pub fn i3c1ie(&self) -> I3C1IE_R {
I3C1IE_R::new(((self.bits >> 19) & 1) != 0)
}
#[doc = "Bit 20 - illegal access interrupt enable for CRS"]
#[inline(always)]
pub fn crsie(&self) -> CRSIE_R {
CRSIE_R::new(((self.bits >> 20) & 1) != 0)
}
#[doc = "Bit 21 - illegal access interrupt enable for USART6"]
#[inline(always)]
pub fn usart6ie(&self) -> USART6IE_R {
USART6IE_R::new(((self.bits >> 21) & 1) != 0)
}
#[doc = "Bit 22 - illegal access interrupt enable for USART10"]
#[inline(always)]
pub fn usart10ie(&self) -> USART10IE_R {
USART10IE_R::new(((self.bits >> 22) & 1) != 0)
}
#[doc = "Bit 23 - illegal access interrupt enable for USART11"]
#[inline(always)]
pub fn usart11ie(&self) -> USART11IE_R {
USART11IE_R::new(((self.bits >> 23) & 1) != 0)
}
#[doc = "Bit 24 - illegal access interrupt enable for HDMICEC"]
#[inline(always)]
pub fn hdmicecie(&self) -> HDMICECIE_R {
HDMICECIE_R::new(((self.bits >> 24) & 1) != 0)
}
#[doc = "Bit 25 - illegal access interrupt enable for DAC1"]
#[inline(always)]
pub fn dac1ie(&self) -> DAC1IE_R {
DAC1IE_R::new(((self.bits >> 25) & 1) != 0)
}
#[doc = "Bit 26 - illegal access interrupt enable for UART7"]
#[inline(always)]
pub fn uart7ie(&self) -> UART7IE_R {
UART7IE_R::new(((self.bits >> 26) & 1) != 0)
}
#[doc = "Bit 27 - illegal access interrupt enable for UART8"]
#[inline(always)]
pub fn uart8ie(&self) -> UART8IE_R {
UART8IE_R::new(((self.bits >> 27) & 1) != 0)
}
#[doc = "Bit 28 - illegal access interrupt enable for UART9"]
#[inline(always)]
pub fn uart9ie(&self) -> UART9IE_R {
UART9IE_R::new(((self.bits >> 28) & 1) != 0)
}
#[doc = "Bit 29 - illegal access interrupt enable for UART12"]
#[inline(always)]
pub fn uart12ie(&self) -> UART12IE_R {
UART12IE_R::new(((self.bits >> 29) & 1) != 0)
}
#[doc = "Bit 30 - illegal access interrupt enable for DTS"]
#[inline(always)]
pub fn dtsie(&self) -> DTSIE_R {
DTSIE_R::new(((self.bits >> 30) & 1) != 0)
}
#[doc = "Bit 31 - illegal access interrupt enable for LPTIM2"]
#[inline(always)]
pub fn lptim2ie(&self) -> LPTIM2IE_R {
LPTIM2IE_R::new(((self.bits >> 31) & 1) != 0)
}
}
impl W {
#[doc = "Bit 0 - illegal access interrupt enable for TIM2"]
#[inline(always)]
#[must_use]
pub fn tim2ie(&mut self) -> TIM2IE_W<GTZC1_TZIC_IER1_SPEC, 0> {
TIM2IE_W::new(self)
}
#[doc = "Bit 1 - illegal access interrupt enable for TIM3"]
#[inline(always)]
#[must_use]
pub fn tim3ie(&mut self) -> TIM3IE_W<GTZC1_TZIC_IER1_SPEC, 1> {
TIM3IE_W::new(self)
}
#[doc = "Bit 2 - illegal access interrupt enable for TIM4"]
#[inline(always)]
#[must_use]
pub fn tim4ie(&mut self) -> TIM4IE_W<GTZC1_TZIC_IER1_SPEC, 2> {
TIM4IE_W::new(self)
}
#[doc = "Bit 3 - illegal access interrupt enable for TIM5"]
#[inline(always)]
#[must_use]
pub fn tim5ie(&mut self) -> TIM5IE_W<GTZC1_TZIC_IER1_SPEC, 3> {
TIM5IE_W::new(self)
}
#[doc = "Bit 4 - illegal access interrupt enable for TIM6"]
#[inline(always)]
#[must_use]
pub fn tim6ie(&mut self) -> TIM6IE_W<GTZC1_TZIC_IER1_SPEC, 4> {
TIM6IE_W::new(self)
}
#[doc = "Bit 5 - illegal access interrupt enable for TIM7"]
#[inline(always)]
#[must_use]
pub fn tim7ie(&mut self) -> TIM7IE_W<GTZC1_TZIC_IER1_SPEC, 5> {
TIM7IE_W::new(self)
}
#[doc = "Bit 6 - illegal access interrupt enable for TIM12"]
#[inline(always)]
#[must_use]
pub fn tim12ie(&mut self) -> TIM12IE_W<GTZC1_TZIC_IER1_SPEC, 6> {
TIM12IE_W::new(self)
}
#[doc = "Bit 7 - illegal access interrupt enable for TIM13"]
#[inline(always)]
#[must_use]
pub fn tim13ie(&mut self) -> TIM13IE_W<GTZC1_TZIC_IER1_SPEC, 7> {
TIM13IE_W::new(self)
}
#[doc = "Bit 8 - illegal access interrupt enable for TIM14"]
#[inline(always)]
#[must_use]
pub fn tim14ie(&mut self) -> TIM14IE_W<GTZC1_TZIC_IER1_SPEC, 8> {
TIM14IE_W::new(self)
}
#[doc = "Bit 9 - illegal access interrupt enable for WWDG"]
#[inline(always)]
#[must_use]
pub fn wwdgie(&mut self) -> WWDGIE_W<GTZC1_TZIC_IER1_SPEC, 9> {
WWDGIE_W::new(self)
}
#[doc = "Bit 10 - illegal access interrupt enable for IWDG"]
#[inline(always)]
#[must_use]
pub fn iwdgie(&mut self) -> IWDGIE_W<GTZC1_TZIC_IER1_SPEC, 10> {
IWDGIE_W::new(self)
}
#[doc = "Bit 11 - illegal access interrupt enable for SPI2"]
#[inline(always)]
#[must_use]
pub fn spi2ie(&mut self) -> SPI2IE_W<GTZC1_TZIC_IER1_SPEC, 11> {
SPI2IE_W::new(self)
}
#[doc = "Bit 12 - illegal access interrupt enable for SPI3"]
#[inline(always)]
#[must_use]
pub fn spi3ie(&mut self) -> SPI3IE_W<GTZC1_TZIC_IER1_SPEC, 12> {
SPI3IE_W::new(self)
}
#[doc = "Bit 13 - illegal access interrupt enable for USART2"]
#[inline(always)]
#[must_use]
pub fn usart2ie(&mut self) -> USART2IE_W<GTZC1_TZIC_IER1_SPEC, 13> {
USART2IE_W::new(self)
}
#[doc = "Bit 14 - illegal access interrupt enable for USART3"]
#[inline(always)]
#[must_use]
pub fn usart3ie(&mut self) -> USART3IE_W<GTZC1_TZIC_IER1_SPEC, 14> {
USART3IE_W::new(self)
}
#[doc = "Bit 15 - illegal access interrupt enable for UART4"]
#[inline(always)]
#[must_use]
pub fn uart4ie(&mut self) -> UART4IE_W<GTZC1_TZIC_IER1_SPEC, 15> {
UART4IE_W::new(self)
}
#[doc = "Bit 16 - illegal access interrupt enable for UART5"]
#[inline(always)]
#[must_use]
pub fn uart5ie(&mut self) -> UART5IE_W<GTZC1_TZIC_IER1_SPEC, 16> {
UART5IE_W::new(self)
}
#[doc = "Bit 17 - illegal access interrupt enable for I2C1"]
#[inline(always)]
#[must_use]
pub fn i2c1ie(&mut self) -> I2C1IE_W<GTZC1_TZIC_IER1_SPEC, 17> {
I2C1IE_W::new(self)
}
#[doc = "Bit 18 - illegal access interrupt enable for I2C2"]
#[inline(always)]
#[must_use]
pub fn i2c2ie(&mut self) -> I2C2IE_W<GTZC1_TZIC_IER1_SPEC, 18> {
I2C2IE_W::new(self)
}
#[doc = "Bit 19 - illegal access interrupt enable for I3C1"]
#[inline(always)]
#[must_use]
pub fn i3c1ie(&mut self) -> I3C1IE_W<GTZC1_TZIC_IER1_SPEC, 19> {
I3C1IE_W::new(self)
}
#[doc = "Bit 20 - illegal access interrupt enable for CRS"]
#[inline(always)]
#[must_use]
pub fn crsie(&mut self) -> CRSIE_W<GTZC1_TZIC_IER1_SPEC, 20> {
CRSIE_W::new(self)
}
#[doc = "Bit 21 - illegal access interrupt enable for USART6"]
#[inline(always)]
#[must_use]
pub fn usart6ie(&mut self) -> USART6IE_W<GTZC1_TZIC_IER1_SPEC, 21> {
USART6IE_W::new(self)
}
#[doc = "Bit 22 - illegal access interrupt enable for USART10"]
#[inline(always)]
#[must_use]
pub fn usart10ie(&mut self) -> USART10IE_W<GTZC1_TZIC_IER1_SPEC, 22> {
USART10IE_W::new(self)
}
#[doc = "Bit 23 - illegal access interrupt enable for USART11"]
#[inline(always)]
#[must_use]
pub fn usart11ie(&mut self) -> USART11IE_W<GTZC1_TZIC_IER1_SPEC, 23> {
USART11IE_W::new(self)
}
#[doc = "Bit 24 - illegal access interrupt enable for HDMICEC"]
#[inline(always)]
#[must_use]
pub fn hdmicecie(&mut self) -> HDMICECIE_W<GTZC1_TZIC_IER1_SPEC, 24> {
HDMICECIE_W::new(self)
}
#[doc = "Bit 25 - illegal access interrupt enable for DAC1"]
#[inline(always)]
#[must_use]
pub fn dac1ie(&mut self) -> DAC1IE_W<GTZC1_TZIC_IER1_SPEC, 25> {
DAC1IE_W::new(self)
}
#[doc = "Bit 26 - illegal access interrupt enable for UART7"]
#[inline(always)]
#[must_use]
pub fn uart7ie(&mut self) -> UART7IE_W<GTZC1_TZIC_IER1_SPEC, 26> {
UART7IE_W::new(self)
}
#[doc = "Bit 27 - illegal access interrupt enable for UART8"]
#[inline(always)]
#[must_use]
pub fn uart8ie(&mut self) -> UART8IE_W<GTZC1_TZIC_IER1_SPEC, 27> {
UART8IE_W::new(self)
}
#[doc = "Bit 28 - illegal access interrupt enable for UART9"]
#[inline(always)]
#[must_use]
pub fn uart9ie(&mut self) -> UART9IE_W<GTZC1_TZIC_IER1_SPEC, 28> {
UART9IE_W::new(self)
}
#[doc = "Bit 29 - illegal access interrupt enable for UART12"]
#[inline(always)]
#[must_use]
pub fn uart12ie(&mut self) -> UART12IE_W<GTZC1_TZIC_IER1_SPEC, 29> {
UART12IE_W::new(self)
}
#[doc = "Bit 30 - illegal access interrupt enable for DTS"]
#[inline(always)]
#[must_use]
pub fn dtsie(&mut self) -> DTSIE_W<GTZC1_TZIC_IER1_SPEC, 30> {
DTSIE_W::new(self)
}
#[doc = "Bit 31 - illegal access interrupt enable for LPTIM2"]
#[inline(always)]
#[must_use]
pub fn lptim2ie(&mut self) -> LPTIM2IE_W<GTZC1_TZIC_IER1_SPEC, 31> {
LPTIM2IE_W::new(self)
}
#[doc = "Writes raw bits to the register."]
#[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.bits = bits;
self
}
}
#[doc = "TZIC interrupt enable register 1\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`gtzc1_tzic_ier1::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`gtzc1_tzic_ier1::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct GTZC1_TZIC_IER1_SPEC;
impl crate::RegisterSpec for GTZC1_TZIC_IER1_SPEC {
type Ux = u32;
}
#[doc = "`read()` method returns [`gtzc1_tzic_ier1::R`](R) reader structure"]
impl crate::Readable for GTZC1_TZIC_IER1_SPEC {}
#[doc = "`write(|w| ..)` method takes [`gtzc1_tzic_ier1::W`](W) writer structure"]
impl crate::Writable for GTZC1_TZIC_IER1_SPEC {
const ZERO_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
}
#[doc = "`reset()` method sets GTZC1_TZIC_IER1 to value 0"]
impl crate::Resettable for GTZC1_TZIC_IER1_SPEC {
const RESET_VALUE: Self::Ux = 0;
}
|
#[test]
fn tuple_destructure() {
mod my_module {
use inherent_pub::inherent_pub;
pub trait Foo {
fn foo(self, a: (i32, i32)) -> i32;
}
pub struct Bar;
#[inherent_pub]
impl Foo for Bar {
pub fn foo(self, (a, b): (i32, i32)) -> i32 {
a + b
}
}
}
assert!(my_module::Bar.foo((40, 2)) == 42);
}
#[test]
fn tuple_struct_destructure() {
mod my_module {
use inherent_pub::inherent_pub;
pub struct Pair(pub i32, pub i32);
pub trait Foo {
fn foo(self, a: Pair) -> i32;
}
pub struct Bar;
#[inherent_pub]
impl Foo for Bar {
pub fn foo(self, Pair(a, b): Pair) -> i32 {
a + b
}
}
}
assert!(my_module::Bar.foo(my_module::Pair(40, 2)) == 42);
}
#[test]
fn struct_destructure() {
mod my_module {
use inherent_pub::inherent_pub;
pub struct Pair {
pub a: i32,
pub b: i32,
}
pub trait Foo {
fn foo(self, a: Pair) -> i32;
}
pub struct Bar;
#[inherent_pub]
impl Foo for Bar {
pub fn foo(self, Pair { a, b: c }: Pair) -> i32 {
a + c
}
}
}
assert!(my_module::Bar.foo(my_module::Pair{ a: 40, b: 2}) == 42);
}
|
use specs::prelude::*;
use cgmath::Vector3;
#[derive(Component)]
pub struct Velocity {
pub vector: Vector3<f64>,
}
impl Velocity {
pub fn new(vector: Vector3<f64>) -> Self {
Self { vector }
}
}
|
use std::collections::HashSet;
/// The type enum is used to define types for Disp's
/// type checker.
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
pub enum Type {
Array(Box<Type>),
Bool,
Byte,
FunctionPrototype,
Int,
None,
String,
Map(Box<Type>, Box<Type>),
}
/// A map that contains all created types.
/// Types should be constructed via the TypeMap,
/// to ensure references to the same type.
pub struct TypeSet {
arrays: HashSet<Type>,
}
impl TypeSet {
pub fn new() -> TypeSet {
let mut type_set = TypeSet{
arrays: HashSet::new()
};
add_builtin_types(&mut type_set);
return type_set;
}
/// Get a genericized array type
pub fn get_array_type(&mut self, value_type: &Type) -> Type {
self.arrays.insert(value_type.clone());
Type::Array(Box::new(value_type.clone()))
}
}
pub fn add_builtin_types(type_set: &mut TypeSet) {
type_set.get_array_type(&Type::Byte);
}
|
mod RSA;
fn main()
{
let mut k = RSA::RSAKey::create();
println!("Value is: {num}", num = RSA::algor::random_num(0u32, 100u32));
}
|
#[doc = r"Register block"]
#[repr(C)]
pub struct RegisterBlock {
#[doc = "0x00 - TCPWM control register"]
pub ctrl: CTRL,
#[doc = "0x04 - TCPWM control clear register"]
pub ctrl_clr: CTRL_CLR,
#[doc = "0x08 - TCPWM control set register"]
pub ctrl_set: CTRL_SET,
#[doc = "0x0c - TCPWM capture command register"]
pub cmd_capture: CMD_CAPTURE,
#[doc = "0x10 - TCPWM reload command register"]
pub cmd_reload: CMD_RELOAD,
#[doc = "0x14 - TCPWM stop command register"]
pub cmd_stop: CMD_STOP,
#[doc = "0x18 - TCPWM start command register"]
pub cmd_start: CMD_START,
#[doc = "0x1c - TCPWM Counter interrupt cause register"]
pub intr_cause: INTR_CAUSE,
_reserved8: [u8; 224usize],
#[doc = "0x100 - Timer/Counter/PWM Counter Module"]
pub cnt: [CNT; 24],
}
#[doc = r"Register block"]
#[repr(C)]
pub struct CNT {
#[doc = "0x00 - Counter control register"]
pub ctrl: self::cnt::CTRL,
#[doc = "0x04 - Counter status register"]
pub status: self::cnt::STATUS,
#[doc = "0x08 - Counter count register"]
pub counter: self::cnt::COUNTER,
#[doc = "0x0c - Counter compare/capture register"]
pub cc: self::cnt::CC,
#[doc = "0x10 - Counter buffered compare/capture register"]
pub cc_buff: self::cnt::CC_BUFF,
#[doc = "0x14 - Counter period register"]
pub period: self::cnt::PERIOD,
#[doc = "0x18 - Counter buffered period register"]
pub period_buff: self::cnt::PERIOD_BUFF,
_reserved7: [u8; 4usize],
#[doc = "0x20 - Counter trigger control register 0"]
pub tr_ctrl0: self::cnt::TR_CTRL0,
#[doc = "0x24 - Counter trigger control register 1"]
pub tr_ctrl1: self::cnt::TR_CTRL1,
#[doc = "0x28 - Counter trigger control register 2"]
pub tr_ctrl2: self::cnt::TR_CTRL2,
_reserved10: [u8; 4usize],
#[doc = "0x30 - Interrupt request register"]
pub intr: self::cnt::INTR,
#[doc = "0x34 - Interrupt set request register"]
pub intr_set: self::cnt::INTR_SET,
#[doc = "0x38 - Interrupt mask register"]
pub intr_mask: self::cnt::INTR_MASK,
#[doc = "0x3c - Interrupt masked request register"]
pub intr_masked: self::cnt::INTR_MASKED,
}
#[doc = r"Register block"]
#[doc = "Timer/Counter/PWM Counter Module"]
pub mod cnt;
#[doc = "TCPWM control register\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about avaliable fields see [ctrl](ctrl) module"]
pub type CTRL = crate::Reg<u32, _CTRL>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _CTRL;
#[doc = "`read()` method returns [ctrl::R](ctrl::R) reader structure"]
impl crate::Readable for CTRL {}
#[doc = "`write(|w| ..)` method takes [ctrl::W](ctrl::W) writer structure"]
impl crate::Writable for CTRL {}
#[doc = "TCPWM control register"]
pub mod ctrl;
#[doc = "TCPWM control clear register\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about avaliable fields see [ctrl_clr](ctrl_clr) module"]
pub type CTRL_CLR = crate::Reg<u32, _CTRL_CLR>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _CTRL_CLR;
#[doc = "`read()` method returns [ctrl_clr::R](ctrl_clr::R) reader structure"]
impl crate::Readable for CTRL_CLR {}
#[doc = "`write(|w| ..)` method takes [ctrl_clr::W](ctrl_clr::W) writer structure"]
impl crate::Writable for CTRL_CLR {}
#[doc = "TCPWM control clear register"]
pub mod ctrl_clr;
#[doc = "TCPWM control set register\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about avaliable fields see [ctrl_set](ctrl_set) module"]
pub type CTRL_SET = crate::Reg<u32, _CTRL_SET>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _CTRL_SET;
#[doc = "`read()` method returns [ctrl_set::R](ctrl_set::R) reader structure"]
impl crate::Readable for CTRL_SET {}
#[doc = "`write(|w| ..)` method takes [ctrl_set::W](ctrl_set::W) writer structure"]
impl crate::Writable for CTRL_SET {}
#[doc = "TCPWM control set register"]
pub mod ctrl_set;
#[doc = "TCPWM capture command register\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about avaliable fields see [cmd_capture](cmd_capture) module"]
pub type CMD_CAPTURE = crate::Reg<u32, _CMD_CAPTURE>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _CMD_CAPTURE;
#[doc = "`read()` method returns [cmd_capture::R](cmd_capture::R) reader structure"]
impl crate::Readable for CMD_CAPTURE {}
#[doc = "`write(|w| ..)` method takes [cmd_capture::W](cmd_capture::W) writer structure"]
impl crate::Writable for CMD_CAPTURE {}
#[doc = "TCPWM capture command register"]
pub mod cmd_capture;
#[doc = "TCPWM reload command register\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about avaliable fields see [cmd_reload](cmd_reload) module"]
pub type CMD_RELOAD = crate::Reg<u32, _CMD_RELOAD>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _CMD_RELOAD;
#[doc = "`read()` method returns [cmd_reload::R](cmd_reload::R) reader structure"]
impl crate::Readable for CMD_RELOAD {}
#[doc = "`write(|w| ..)` method takes [cmd_reload::W](cmd_reload::W) writer structure"]
impl crate::Writable for CMD_RELOAD {}
#[doc = "TCPWM reload command register"]
pub mod cmd_reload;
#[doc = "TCPWM stop command register\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about avaliable fields see [cmd_stop](cmd_stop) module"]
pub type CMD_STOP = crate::Reg<u32, _CMD_STOP>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _CMD_STOP;
#[doc = "`read()` method returns [cmd_stop::R](cmd_stop::R) reader structure"]
impl crate::Readable for CMD_STOP {}
#[doc = "`write(|w| ..)` method takes [cmd_stop::W](cmd_stop::W) writer structure"]
impl crate::Writable for CMD_STOP {}
#[doc = "TCPWM stop command register"]
pub mod cmd_stop;
#[doc = "TCPWM start command register\n\nThis register you can [`read`](crate::generic::Reg::read), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about avaliable fields see [cmd_start](cmd_start) module"]
pub type CMD_START = crate::Reg<u32, _CMD_START>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _CMD_START;
#[doc = "`read()` method returns [cmd_start::R](cmd_start::R) reader structure"]
impl crate::Readable for CMD_START {}
#[doc = "`write(|w| ..)` method takes [cmd_start::W](cmd_start::W) writer structure"]
impl crate::Writable for CMD_START {}
#[doc = "TCPWM start command register"]
pub mod cmd_start;
#[doc = "TCPWM Counter interrupt cause register\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about avaliable fields see [intr_cause](intr_cause) module"]
pub type INTR_CAUSE = crate::Reg<u32, _INTR_CAUSE>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _INTR_CAUSE;
#[doc = "`read()` method returns [intr_cause::R](intr_cause::R) reader structure"]
impl crate::Readable for INTR_CAUSE {}
#[doc = "TCPWM Counter interrupt cause register"]
pub mod intr_cause;
|
use std::option::Option::Some;
/// 定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的 min 函数在该栈中，
/// 调用 min、push 及 pop 的时间复杂度都是 O(1)。
///
/// MinStack minStack = new MinStack();
/// minStack.push(-2);
/// minStack.push(0);
/// minStack.push(-3);
/// minStack.min(); --> 返回 -3.
/// minStack.pop();
/// minStack.top(); --> 返回 0.
/// minStack.min(); --> 返回 -2.
/**
* Your MinStack object will be instantiated and called as such:
* let obj = MinStack::new();
* obj.push(x);
* obj.pop();
* let ret_3: i32 = obj.top();
* let ret_4: i32 = obj.min();
*/
pub fn main() {
let mut obj = MinStack::new();
obj.push(-3);
obj.push(0);
obj.push(-1);
obj.pop();
let ret_3: i32 = obj.top();
let ret_4: i32 = obj.min();
println!("top：{}", ret_3);
println!("min：{}", ret_4);
}
struct MinStack {
stack_real: Vec<i32>,
stack_min: Vec<i32>,
}
/**
* `&self` means the method takes an immutable reference.
* If you need a mutable reference, change it to `&mut self` instead.
*/
impl MinStack {
/** initialize your data structure here. */
fn new() -> Self {
MinStack {
stack_real: Vec::new(),
stack_min: Vec::new(),
}
}
fn push(&mut self, x: i32) {
if self.stack_min.is_empty() {
self.stack_real.push(x);
self.stack_min.push(x);
} else if self.stack_min[self.stack_min.len() - 1] >= x {
self.stack_real.push(x);
self.stack_min.push(x);
} else {
self.stack_real.push(x);
}
}
fn pop(&mut self) {
match self.stack_real.pop() {
Some(value) if !self.stack_min.is_empty() && value == self.stack_min[self.stack_min.len() - 1] => {
self.stack_min.pop();
}
_ => {}
}
}
fn top(&self) -> i32 {
if !self.stack_real.is_empty() {
return self.stack_real[self.stack_real.len() - 1];
}
-1
}
fn min(&self) -> i32 {
if !self.stack_min.is_empty() {
return self.stack_min[self.stack_min.len() - 1];
}
-1
}
}
|
use actix_web::{web, get, Responder};
#[get("/version")]
async fn version() -> impl Responder {
// Will replace with the crate version on build
env!("CARGO_PKG_VERSION")
}
pub(super) fn scoped_config(cfg: &mut web::ServiceConfig) {
cfg.service(version);
}
|
fn main() {
//this is not edututeedd
println!("Hello, world!");
}
|
pub mod tuple_array;
pub mod function;
|
#[doc = "Register `SAI_ACR1` reader"]
pub type R = crate::R<SAI_ACR1_SPEC>;
#[doc = "Register `SAI_ACR1` writer"]
pub type W = crate::W<SAI_ACR1_SPEC>;
#[doc = "Field `MODE` reader - MODE"]
pub type MODE_R = crate::FieldReader;
#[doc = "Field `MODE` writer - MODE"]
pub type MODE_W<'a, REG, const O: u8> = crate::FieldWriter<'a, REG, 2, O>;
#[doc = "Field `PRTCFG` reader - PRTCFG"]
pub type PRTCFG_R = crate::FieldReader;
#[doc = "Field `PRTCFG` writer - PRTCFG"]
pub type PRTCFG_W<'a, REG, const O: u8> = crate::FieldWriter<'a, REG, 2, O>;
#[doc = "Field `DS` reader - DS"]
pub type DS_R = crate::FieldReader;
#[doc = "Field `DS` writer - DS"]
pub type DS_W<'a, REG, const O: u8> = crate::FieldWriter<'a, REG, 3, O>;
#[doc = "Field `LSBFIRST` reader - LSBFIRST"]
pub type LSBFIRST_R = crate::BitReader;
#[doc = "Field `LSBFIRST` writer - LSBFIRST"]
pub type LSBFIRST_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `CKSTR` reader - CKSTR"]
pub type CKSTR_R = crate::BitReader;
#[doc = "Field `CKSTR` writer - CKSTR"]
pub type CKSTR_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `SYNCEN` reader - SYNCEN"]
pub type SYNCEN_R = crate::FieldReader;
#[doc = "Field `SYNCEN` writer - SYNCEN"]
pub type SYNCEN_W<'a, REG, const O: u8> = crate::FieldWriter<'a, REG, 2, O>;
#[doc = "Field `MONO` reader - MONO"]
pub type MONO_R = crate::BitReader;
#[doc = "Field `MONO` writer - MONO"]
pub type MONO_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `OUTDRIV` reader - OUTDRIV"]
pub type OUTDRIV_R = crate::BitReader;
#[doc = "Field `OUTDRIV` writer - OUTDRIV"]
pub type OUTDRIV_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `SAIEN` reader - SAIEN"]
pub type SAIEN_R = crate::BitReader;
#[doc = "Field `SAIEN` writer - SAIEN"]
pub type SAIEN_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `DMAEN` reader - DMAEN"]
pub type DMAEN_R = crate::BitReader;
#[doc = "Field `DMAEN` writer - DMAEN"]
pub type DMAEN_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `NODIV` reader - NODIV"]
pub type NODIV_R = crate::BitReader;
#[doc = "Field `NODIV` writer - NODIV"]
pub type NODIV_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `MCKDIV` reader - MCKDIV"]
pub type MCKDIV_R = crate::FieldReader;
#[doc = "Field `MCKDIV` writer - MCKDIV"]
pub type MCKDIV_W<'a, REG, const O: u8> = crate::FieldWriter<'a, REG, 6, O>;
#[doc = "Field `OSR` reader - OSR"]
pub type OSR_R = crate::BitReader;
#[doc = "Field `OSR` writer - OSR"]
pub type OSR_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `MCKEN` reader - MCKEN"]
pub type MCKEN_R = crate::BitReader;
#[doc = "Field `MCKEN` writer - MCKEN"]
pub type MCKEN_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
impl R {
#[doc = "Bits 0:1 - MODE"]
#[inline(always)]
pub fn mode(&self) -> MODE_R {
MODE_R::new((self.bits & 3) as u8)
}
#[doc = "Bits 2:3 - PRTCFG"]
#[inline(always)]
pub fn prtcfg(&self) -> PRTCFG_R {
PRTCFG_R::new(((self.bits >> 2) & 3) as u8)
}
#[doc = "Bits 5:7 - DS"]
#[inline(always)]
pub fn ds(&self) -> DS_R {
DS_R::new(((self.bits >> 5) & 7) as u8)
}
#[doc = "Bit 8 - LSBFIRST"]
#[inline(always)]
pub fn lsbfirst(&self) -> LSBFIRST_R {
LSBFIRST_R::new(((self.bits >> 8) & 1) != 0)
}
#[doc = "Bit 9 - CKSTR"]
#[inline(always)]
pub fn ckstr(&self) -> CKSTR_R {
CKSTR_R::new(((self.bits >> 9) & 1) != 0)
}
#[doc = "Bits 10:11 - SYNCEN"]
#[inline(always)]
pub fn syncen(&self) -> SYNCEN_R {
SYNCEN_R::new(((self.bits >> 10) & 3) as u8)
}
#[doc = "Bit 12 - MONO"]
#[inline(always)]
pub fn mono(&self) -> MONO_R {
MONO_R::new(((self.bits >> 12) & 1) != 0)
}
#[doc = "Bit 13 - OUTDRIV"]
#[inline(always)]
pub fn outdriv(&self) -> OUTDRIV_R {
OUTDRIV_R::new(((self.bits >> 13) & 1) != 0)
}
#[doc = "Bit 16 - SAIEN"]
#[inline(always)]
pub fn saien(&self) -> SAIEN_R {
SAIEN_R::new(((self.bits >> 16) & 1) != 0)
}
#[doc = "Bit 17 - DMAEN"]
#[inline(always)]
pub fn dmaen(&self) -> DMAEN_R {
DMAEN_R::new(((self.bits >> 17) & 1) != 0)
}
#[doc = "Bit 19 - NODIV"]
#[inline(always)]
pub fn nodiv(&self) -> NODIV_R {
NODIV_R::new(((self.bits >> 19) & 1) != 0)
}
#[doc = "Bits 20:25 - MCKDIV"]
#[inline(always)]
pub fn mckdiv(&self) -> MCKDIV_R {
MCKDIV_R::new(((self.bits >> 20) & 0x3f) as u8)
}
#[doc = "Bit 26 - OSR"]
#[inline(always)]
pub fn osr(&self) -> OSR_R {
OSR_R::new(((self.bits >> 26) & 1) != 0)
}
#[doc = "Bit 27 - MCKEN"]
#[inline(always)]
pub fn mcken(&self) -> MCKEN_R {
MCKEN_R::new(((self.bits >> 27) & 1) != 0)
}
}
impl W {
#[doc = "Bits 0:1 - MODE"]
#[inline(always)]
#[must_use]
pub fn mode(&mut self) -> MODE_W<SAI_ACR1_SPEC, 0> {
MODE_W::new(self)
}
#[doc = "Bits 2:3 - PRTCFG"]
#[inline(always)]
#[must_use]
pub fn prtcfg(&mut self) -> PRTCFG_W<SAI_ACR1_SPEC, 2> {
PRTCFG_W::new(self)
}
#[doc = "Bits 5:7 - DS"]
#[inline(always)]
#[must_use]
pub fn ds(&mut self) -> DS_W<SAI_ACR1_SPEC, 5> {
DS_W::new(self)
}
#[doc = "Bit 8 - LSBFIRST"]
#[inline(always)]
#[must_use]
pub fn lsbfirst(&mut self) -> LSBFIRST_W<SAI_ACR1_SPEC, 8> {
LSBFIRST_W::new(self)
}
#[doc = "Bit 9 - CKSTR"]
#[inline(always)]
#[must_use]
pub fn ckstr(&mut self) -> CKSTR_W<SAI_ACR1_SPEC, 9> {
CKSTR_W::new(self)
}
#[doc = "Bits 10:11 - SYNCEN"]
#[inline(always)]
#[must_use]
pub fn syncen(&mut self) -> SYNCEN_W<SAI_ACR1_SPEC, 10> {
SYNCEN_W::new(self)
}
#[doc = "Bit 12 - MONO"]
#[inline(always)]
#[must_use]
pub fn mono(&mut self) -> MONO_W<SAI_ACR1_SPEC, 12> {
MONO_W::new(self)
}
#[doc = "Bit 13 - OUTDRIV"]
#[inline(always)]
#[must_use]
pub fn outdriv(&mut self) -> OUTDRIV_W<SAI_ACR1_SPEC, 13> {
OUTDRIV_W::new(self)
}
#[doc = "Bit 16 - SAIEN"]
#[inline(always)]
#[must_use]
pub fn saien(&mut self) -> SAIEN_W<SAI_ACR1_SPEC, 16> {
SAIEN_W::new(self)
}
#[doc = "Bit 17 - DMAEN"]
#[inline(always)]
#[must_use]
pub fn dmaen(&mut self) -> DMAEN_W<SAI_ACR1_SPEC, 17> {
DMAEN_W::new(self)
}
#[doc = "Bit 19 - NODIV"]
#[inline(always)]
#[must_use]
pub fn nodiv(&mut self) -> NODIV_W<SAI_ACR1_SPEC, 19> {
NODIV_W::new(self)
}
#[doc = "Bits 20:25 - MCKDIV"]
#[inline(always)]
#[must_use]
pub fn mckdiv(&mut self) -> MCKDIV_W<SAI_ACR1_SPEC, 20> {
MCKDIV_W::new(self)
}
#[doc = "Bit 26 - OSR"]
#[inline(always)]
#[must_use]
pub fn osr(&mut self) -> OSR_W<SAI_ACR1_SPEC, 26> {
OSR_W::new(self)
}
#[doc = "Bit 27 - MCKEN"]
#[inline(always)]
#[must_use]
pub fn mcken(&mut self) -> MCKEN_W<SAI_ACR1_SPEC, 27> {
MCKEN_W::new(self)
}
#[doc = "Writes raw bits to the register."]
#[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.bits = bits;
self
}
}
#[doc = "Configuration register 1\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`sai_acr1::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`sai_acr1::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct SAI_ACR1_SPEC;
impl crate::RegisterSpec for SAI_ACR1_SPEC {
type Ux = u32;
}
#[doc = "`read()` method returns [`sai_acr1::R`](R) reader structure"]
impl crate::Readable for SAI_ACR1_SPEC {}
#[doc = "`write(|w| ..)` method takes [`sai_acr1::W`](W) writer structure"]
impl crate::Writable for SAI_ACR1_SPEC {
const ZERO_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
}
#[doc = "`reset()` method sets SAI_ACR1 to value 0x40"]
impl crate::Resettable for SAI_ACR1_SPEC {
const RESET_VALUE: Self::Ux = 0x40;
}
|
#[doc = "Reader of register LE_PING_TIMER_OFFSET"]
pub type R = crate::R<u32, super::LE_PING_TIMER_OFFSET>;
#[doc = "Writer for register LE_PING_TIMER_OFFSET"]
pub type W = crate::W<u32, super::LE_PING_TIMER_OFFSET>;
#[doc = "Register LE_PING_TIMER_OFFSET `reset()`'s with value 0"]
impl crate::ResetValue for super::LE_PING_TIMER_OFFSET {
type Type = u32;
#[inline(always)]
fn reset_value() -> Self::Type {
0
}
}
#[doc = "Reader of field `CONN_PING_TIMER_OFFSET`"]
pub type CONN_PING_TIMER_OFFSET_R = crate::R<u16, u16>;
#[doc = "Write proxy for field `CONN_PING_TIMER_OFFSET`"]
pub struct CONN_PING_TIMER_OFFSET_W<'a> {
w: &'a mut W,
}
impl<'a> CONN_PING_TIMER_OFFSET_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u16) -> &'a mut W {
self.w.bits = (self.w.bits & !0xffff) | ((value as u32) & 0xffff);
self.w
}
}
impl R {
#[doc = "Bits 0:15 - The value of ping timer nearly expired offset in the order of 10ms, valid range 0x0 ~ 0xFFFF. This is the time period after which the ping timer nearly expired interrupt is generated."]
#[inline(always)]
pub fn conn_ping_timer_offset(&self) -> CONN_PING_TIMER_OFFSET_R {
CONN_PING_TIMER_OFFSET_R::new((self.bits & 0xffff) as u16)
}
}
impl W {
#[doc = "Bits 0:15 - The value of ping timer nearly expired offset in the order of 10ms, valid range 0x0 ~ 0xFFFF. This is the time period after which the ping timer nearly expired interrupt is generated."]
#[inline(always)]
pub fn conn_ping_timer_offset(&mut self) -> CONN_PING_TIMER_OFFSET_W {
CONN_PING_TIMER_OFFSET_W { w: self }
}
}
|
#[doc = "Register `C1_APB4ENR` reader"]
pub type R = crate::R<C1_APB4ENR_SPEC>;
#[doc = "Register `C1_APB4ENR` writer"]
pub type W = crate::W<C1_APB4ENR_SPEC>;
#[doc = "Field `SYSCFGEN` reader - SYSCFG peripheral clock enable"]
pub type SYSCFGEN_R = crate::BitReader<SYSCFGEN_A>;
#[doc = "SYSCFG peripheral clock enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum SYSCFGEN_A {
#[doc = "0: The selected clock is disabled"]
Disabled = 0,
#[doc = "1: The selected clock is enabled"]
Enabled = 1,
}
impl From<SYSCFGEN_A> for bool {
#[inline(always)]
fn from(variant: SYSCFGEN_A) -> Self {
variant as u8 != 0
}
}
impl SYSCFGEN_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> SYSCFGEN_A {
match self.bits {
false => SYSCFGEN_A::Disabled,
true => SYSCFGEN_A::Enabled,
}
}
#[doc = "The selected clock is disabled"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
*self == SYSCFGEN_A::Disabled
}
#[doc = "The selected clock is enabled"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
*self == SYSCFGEN_A::Enabled
}
}
#[doc = "Field `SYSCFGEN` writer - SYSCFG peripheral clock enable"]
pub type SYSCFGEN_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O, SYSCFGEN_A>;
impl<'a, REG, const O: u8> SYSCFGEN_W<'a, REG, O>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "The selected clock is disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut crate::W<REG> {
self.variant(SYSCFGEN_A::Disabled)
}
#[doc = "The selected clock is enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut crate::W<REG> {
self.variant(SYSCFGEN_A::Enabled)
}
}
#[doc = "Field `LPUART1EN` reader - LPUART1 Peripheral Clocks Enable"]
pub use SYSCFGEN_R as LPUART1EN_R;
#[doc = "Field `SPI6EN` reader - SPI6 Peripheral Clocks Enable"]
pub use SYSCFGEN_R as SPI6EN_R;
#[doc = "Field `I2C4EN` reader - I2C4 Peripheral Clocks Enable"]
pub use SYSCFGEN_R as I2C4EN_R;
#[doc = "Field `LPTIM2EN` reader - LPTIM2 Peripheral Clocks Enable"]
pub use SYSCFGEN_R as LPTIM2EN_R;
#[doc = "Field `LPTIM3EN` reader - LPTIM3 Peripheral Clocks Enable"]
pub use SYSCFGEN_R as LPTIM3EN_R;
#[doc = "Field `LPTIM4EN` reader - LPTIM4 Peripheral Clocks Enable"]
pub use SYSCFGEN_R as LPTIM4EN_R;
#[doc = "Field `LPTIM5EN` reader - LPTIM5 Peripheral Clocks Enable"]
pub use SYSCFGEN_R as LPTIM5EN_R;
#[doc = "Field `COMP12EN` reader - COMP1/2 peripheral clock enable"]
pub use SYSCFGEN_R as COMP12EN_R;
#[doc = "Field `VREFEN` reader - VREF peripheral clock enable"]
pub use SYSCFGEN_R as VREFEN_R;
#[doc = "Field `RTCAPBEN` reader - RTC APB Clock Enable"]
pub use SYSCFGEN_R as RTCAPBEN_R;
#[doc = "Field `SAI4EN` reader - SAI4 Peripheral Clocks Enable"]
pub use SYSCFGEN_R as SAI4EN_R;
#[doc = "Field `LPUART1EN` writer - LPUART1 Peripheral Clocks Enable"]
pub use SYSCFGEN_W as LPUART1EN_W;
#[doc = "Field `SPI6EN` writer - SPI6 Peripheral Clocks Enable"]
pub use SYSCFGEN_W as SPI6EN_W;
#[doc = "Field `I2C4EN` writer - I2C4 Peripheral Clocks Enable"]
pub use SYSCFGEN_W as I2C4EN_W;
#[doc = "Field `LPTIM2EN` writer - LPTIM2 Peripheral Clocks Enable"]
pub use SYSCFGEN_W as LPTIM2EN_W;
#[doc = "Field `LPTIM3EN` writer - LPTIM3 Peripheral Clocks Enable"]
pub use SYSCFGEN_W as LPTIM3EN_W;
#[doc = "Field `LPTIM4EN` writer - LPTIM4 Peripheral Clocks Enable"]
pub use SYSCFGEN_W as LPTIM4EN_W;
#[doc = "Field `LPTIM5EN` writer - LPTIM5 Peripheral Clocks Enable"]
pub use SYSCFGEN_W as LPTIM5EN_W;
#[doc = "Field `COMP12EN` writer - COMP1/2 peripheral clock enable"]
pub use SYSCFGEN_W as COMP12EN_W;
#[doc = "Field `VREFEN` writer - VREF peripheral clock enable"]
pub use SYSCFGEN_W as VREFEN_W;
#[doc = "Field `RTCAPBEN` writer - RTC APB Clock Enable"]
pub use SYSCFGEN_W as RTCAPBEN_W;
#[doc = "Field `SAI4EN` writer - SAI4 Peripheral Clocks Enable"]
pub use SYSCFGEN_W as SAI4EN_W;
impl R {
#[doc = "Bit 1 - SYSCFG peripheral clock enable"]
#[inline(always)]
pub fn syscfgen(&self) -> SYSCFGEN_R {
SYSCFGEN_R::new(((self.bits >> 1) & 1) != 0)
}
#[doc = "Bit 3 - LPUART1 Peripheral Clocks Enable"]
#[inline(always)]
pub fn lpuart1en(&self) -> LPUART1EN_R {
LPUART1EN_R::new(((self.bits >> 3) & 1) != 0)
}
#[doc = "Bit 5 - SPI6 Peripheral Clocks Enable"]
#[inline(always)]
pub fn spi6en(&self) -> SPI6EN_R {
SPI6EN_R::new(((self.bits >> 5) & 1) != 0)
}
#[doc = "Bit 7 - I2C4 Peripheral Clocks Enable"]
#[inline(always)]
pub fn i2c4en(&self) -> I2C4EN_R {
I2C4EN_R::new(((self.bits >> 7) & 1) != 0)
}
#[doc = "Bit 9 - LPTIM2 Peripheral Clocks Enable"]
#[inline(always)]
pub fn lptim2en(&self) -> LPTIM2EN_R {
LPTIM2EN_R::new(((self.bits >> 9) & 1) != 0)
}
#[doc = "Bit 10 - LPTIM3 Peripheral Clocks Enable"]
#[inline(always)]
pub fn lptim3en(&self) -> LPTIM3EN_R {
LPTIM3EN_R::new(((self.bits >> 10) & 1) != 0)
}
#[doc = "Bit 11 - LPTIM4 Peripheral Clocks Enable"]
#[inline(always)]
pub fn lptim4en(&self) -> LPTIM4EN_R {
LPTIM4EN_R::new(((self.bits >> 11) & 1) != 0)
}
#[doc = "Bit 12 - LPTIM5 Peripheral Clocks Enable"]
#[inline(always)]
pub fn lptim5en(&self) -> LPTIM5EN_R {
LPTIM5EN_R::new(((self.bits >> 12) & 1) != 0)
}
#[doc = "Bit 14 - COMP1/2 peripheral clock enable"]
#[inline(always)]
pub fn comp12en(&self) -> COMP12EN_R {
COMP12EN_R::new(((self.bits >> 14) & 1) != 0)
}
#[doc = "Bit 15 - VREF peripheral clock enable"]
#[inline(always)]
pub fn vrefen(&self) -> VREFEN_R {
VREFEN_R::new(((self.bits >> 15) & 1) != 0)
}
#[doc = "Bit 16 - RTC APB Clock Enable"]
#[inline(always)]
pub fn rtcapben(&self) -> RTCAPBEN_R {
RTCAPBEN_R::new(((self.bits >> 16) & 1) != 0)
}
#[doc = "Bit 21 - SAI4 Peripheral Clocks Enable"]
#[inline(always)]
pub fn sai4en(&self) -> SAI4EN_R {
SAI4EN_R::new(((self.bits >> 21) & 1) != 0)
}
}
impl W {
#[doc = "Bit 1 - SYSCFG peripheral clock enable"]
#[inline(always)]
#[must_use]
pub fn syscfgen(&mut self) -> SYSCFGEN_W<C1_APB4ENR_SPEC, 1> {
SYSCFGEN_W::new(self)
}
#[doc = "Bit 3 - LPUART1 Peripheral Clocks Enable"]
#[inline(always)]
#[must_use]
pub fn lpuart1en(&mut self) -> LPUART1EN_W<C1_APB4ENR_SPEC, 3> {
LPUART1EN_W::new(self)
}
#[doc = "Bit 5 - SPI6 Peripheral Clocks Enable"]
#[inline(always)]
#[must_use]
pub fn spi6en(&mut self) -> SPI6EN_W<C1_APB4ENR_SPEC, 5> {
SPI6EN_W::new(self)
}
#[doc = "Bit 7 - I2C4 Peripheral Clocks Enable"]
#[inline(always)]
#[must_use]
pub fn i2c4en(&mut self) -> I2C4EN_W<C1_APB4ENR_SPEC, 7> {
I2C4EN_W::new(self)
}
#[doc = "Bit 9 - LPTIM2 Peripheral Clocks Enable"]
#[inline(always)]
#[must_use]
pub fn lptim2en(&mut self) -> LPTIM2EN_W<C1_APB4ENR_SPEC, 9> {
LPTIM2EN_W::new(self)
}
#[doc = "Bit 10 - LPTIM3 Peripheral Clocks Enable"]
#[inline(always)]
#[must_use]
pub fn lptim3en(&mut self) -> LPTIM3EN_W<C1_APB4ENR_SPEC, 10> {
LPTIM3EN_W::new(self)
}
#[doc = "Bit 11 - LPTIM4 Peripheral Clocks Enable"]
#[inline(always)]
#[must_use]
pub fn lptim4en(&mut self) -> LPTIM4EN_W<C1_APB4ENR_SPEC, 11> {
LPTIM4EN_W::new(self)
}
#[doc = "Bit 12 - LPTIM5 Peripheral Clocks Enable"]
#[inline(always)]
#[must_use]
pub fn lptim5en(&mut self) -> LPTIM5EN_W<C1_APB4ENR_SPEC, 12> {
LPTIM5EN_W::new(self)
}
#[doc = "Bit 14 - COMP1/2 peripheral clock enable"]
#[inline(always)]
#[must_use]
pub fn comp12en(&mut self) -> COMP12EN_W<C1_APB4ENR_SPEC, 14> {
COMP12EN_W::new(self)
}
#[doc = "Bit 15 - VREF peripheral clock enable"]
#[inline(always)]
#[must_use]
pub fn vrefen(&mut self) -> VREFEN_W<C1_APB4ENR_SPEC, 15> {
VREFEN_W::new(self)
}
#[doc = "Bit 16 - RTC APB Clock Enable"]
#[inline(always)]
#[must_use]
pub fn rtcapben(&mut self) -> RTCAPBEN_W<C1_APB4ENR_SPEC, 16> {
RTCAPBEN_W::new(self)
}
#[doc = "Bit 21 - SAI4 Peripheral Clocks Enable"]
#[inline(always)]
#[must_use]
pub fn sai4en(&mut self) -> SAI4EN_W<C1_APB4ENR_SPEC, 21> {
SAI4EN_W::new(self)
}
#[doc = "Writes raw bits to the register."]
#[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.bits = bits;
self
}
}
#[doc = "RCC APB4 Clock Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`c1_apb4enr::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`c1_apb4enr::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct C1_APB4ENR_SPEC;
impl crate::RegisterSpec for C1_APB4ENR_SPEC {
type Ux = u32;
}
#[doc = "`read()` method returns [`c1_apb4enr::R`](R) reader structure"]
impl crate::Readable for C1_APB4ENR_SPEC {}
#[doc = "`write(|w| ..)` method takes [`c1_apb4enr::W`](W) writer structure"]
impl crate::Writable for C1_APB4ENR_SPEC {
const ZERO_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
}
#[doc = "`reset()` method sets C1_APB4ENR to value 0x0001_0000"]
impl crate::Resettable for C1_APB4ENR_SPEC {
const RESET_VALUE: Self::Ux = 0x0001_0000;
}
|
#![doc = "generated by AutoRust 0.1.0"]
#![allow(non_camel_case_types)]
#![allow(unused_imports)]
use serde::{Deserialize, Serialize};
pub type PortNumber = i64;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Rule {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub direction: Option<rule::Direction>,
#[serde(rename = "destinationPort", default, skip_serializing_if = "Option::is_none")]
pub destination_port: Option<PortNumber>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub protocols: Vec<String>,
#[serde(rename = "ipAddresses", default, skip_serializing_if = "Vec::is_empty")]
pub ip_addresses: Vec<String>,
}
pub mod rule {
use super::*;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum Direction {
Inbound,
Outbound,
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct EffectiveNetworkSecurityGroups {
#[serde(rename = "networkInterface", default, skip_serializing_if = "Option::is_none")]
pub network_interface: Option<String>,
#[serde(rename = "networkSecurityGroups", default, skip_serializing_if = "Vec::is_empty")]
pub network_security_groups: Vec<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AdaptiveNetworkHardeningProperties {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub rules: Vec<Rule>,
#[serde(rename = "rulesCalculationTime", default, skip_serializing_if = "Option::is_none")]
pub rules_calculation_time: Option<String>,
#[serde(rename = "effectiveNetworkSecurityGroups", default, skip_serializing_if = "Vec::is_empty")]
pub effective_network_security_groups: Vec<EffectiveNetworkSecurityGroups>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AdaptiveNetworkHardening {
#[serde(flatten)]
pub resource: Resource,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub properties: Option<AdaptiveNetworkHardeningProperties>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AdaptiveNetworkHardeningsList {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub value: Vec<AdaptiveNetworkHardening>,
#[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
pub next_link: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AdaptiveNetworkHardeningEnforceRequest {
pub rules: Vec<Rule>,
#[serde(rename = "networkSecurityGroups")]
pub network_security_groups: Vec<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AlertList {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub value: Vec<Alert>,
#[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
pub next_link: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Alert {
#[serde(flatten)]
pub resource: Resource,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub properties: Option<AlertProperties>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AlertProperties {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
#[serde(rename = "reportedTimeUtc", default, skip_serializing_if = "Option::is_none")]
pub reported_time_utc: Option<String>,
#[serde(rename = "vendorName", default, skip_serializing_if = "Option::is_none")]
pub vendor_name: Option<String>,
#[serde(rename = "alertName", default, skip_serializing_if = "Option::is_none")]
pub alert_name: Option<String>,
#[serde(rename = "alertDisplayName", default, skip_serializing_if = "Option::is_none")]
pub alert_display_name: Option<String>,
#[serde(rename = "detectedTimeUtc", default, skip_serializing_if = "Option::is_none")]
pub detected_time_utc: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "remediationSteps", default, skip_serializing_if = "Option::is_none")]
pub remediation_steps: Option<String>,
#[serde(rename = "actionTaken", default, skip_serializing_if = "Option::is_none")]
pub action_taken: Option<String>,
#[serde(rename = "reportedSeverity", default, skip_serializing_if = "Option::is_none")]
pub reported_severity: Option<alert_properties::ReportedSeverity>,
#[serde(rename = "compromisedEntity", default, skip_serializing_if = "Option::is_none")]
pub compromised_entity: Option<String>,
#[serde(rename = "associatedResource", default, skip_serializing_if = "Option::is_none")]
pub associated_resource: Option<String>,
#[serde(rename = "extendedProperties", default, skip_serializing_if = "Option::is_none")]
pub extended_properties: Option<AlertExtendedProperties>,
#[serde(rename = "systemSource", default, skip_serializing_if = "Option::is_none")]
pub system_source: Option<String>,
#[serde(rename = "canBeInvestigated", default, skip_serializing_if = "Option::is_none")]
pub can_be_investigated: Option<bool>,
#[serde(rename = "isIncident", default, skip_serializing_if = "Option::is_none")]
pub is_incident: Option<bool>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub entities: Vec<AlertEntity>,
#[serde(rename = "confidenceScore", default, skip_serializing_if = "Option::is_none")]
pub confidence_score: Option<f32>,
#[serde(rename = "confidenceReasons", default, skip_serializing_if = "Vec::is_empty")]
pub confidence_reasons: Vec<AlertConfidenceReason>,
#[serde(rename = "subscriptionId", default, skip_serializing_if = "Option::is_none")]
pub subscription_id: Option<String>,
#[serde(rename = "instanceId", default, skip_serializing_if = "Option::is_none")]
pub instance_id: Option<String>,
#[serde(rename = "workspaceArmId", default, skip_serializing_if = "Option::is_none")]
pub workspace_arm_id: Option<String>,
#[serde(rename = "correlationKey", default, skip_serializing_if = "Option::is_none")]
pub correlation_key: Option<String>,
}
pub mod alert_properties {
use super::*;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum ReportedSeverity {
Silent,
Information,
Low,
High,
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AlertConfidenceReason {
#[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub reason: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AlertEntity {
#[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AlertExtendedProperties {}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AllowedConnectionsList {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub value: Vec<AllowedConnectionsResource>,
#[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
pub next_link: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AllowedConnectionsResource {
#[serde(flatten)]
pub resource: Resource,
#[serde(flatten)]
pub location: Location,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub properties: Option<AllowedConnectionsResourceProperties>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AllowedConnectionsResourceProperties {
#[serde(rename = "calculatedDateTime", default, skip_serializing_if = "Option::is_none")]
pub calculated_date_time: Option<String>,
#[serde(rename = "connectableResources", default, skip_serializing_if = "Vec::is_empty")]
pub connectable_resources: Vec<ConnectableResource>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ConnectableResource {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "inboundConnectedResources", default, skip_serializing_if = "Vec::is_empty")]
pub inbound_connected_resources: Vec<ConnectedResource>,
#[serde(rename = "outboundConnectedResources", default, skip_serializing_if = "Vec::is_empty")]
pub outbound_connected_resources: Vec<ConnectedResource>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ConnectedResource {
#[serde(rename = "connectedResourceId", default, skip_serializing_if = "Option::is_none")]
pub connected_resource_id: Option<String>,
#[serde(rename = "tcpPorts", default, skip_serializing_if = "Option::is_none")]
pub tcp_ports: Option<String>,
#[serde(rename = "udpPorts", default, skip_serializing_if = "Option::is_none")]
pub udp_ports: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AppWhitelistingGroups {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub value: Vec<AppWhitelistingGroup>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AppWhitelistingGroup {
#[serde(flatten)]
pub resource: Resource,
#[serde(flatten)]
pub location: Location,
pub properties: AppWhitelistingGroupData,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AppWhitelistingGroupData {
#[serde(rename = "enforcementMode", default, skip_serializing_if = "Option::is_none")]
pub enforcement_mode: Option<EnforcementMode>,
#[serde(rename = "protectionMode", default, skip_serializing_if = "Option::is_none")]
pub protection_mode: Option<ProtectionMode>,
#[serde(rename = "configurationStatus", default, skip_serializing_if = "Option::is_none")]
pub configuration_status: Option<ConfigurationStatus>,
#[serde(rename = "recommendationStatus", default, skip_serializing_if = "Option::is_none")]
pub recommendation_status: Option<RecommendationStatus>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub issues: Option<AppWhitelistingIssuesSummaries>,
#[serde(rename = "sourceSystem", default, skip_serializing_if = "Option::is_none")]
pub source_system: Option<SourceSystem>,
#[serde(rename = "vmRecommendations", default, skip_serializing_if = "Option::is_none")]
pub vm_recommendations: Option<VmRecommendations>,
#[serde(rename = "pathRecommendations", default, skip_serializing_if = "Option::is_none")]
pub path_recommendations: Option<PathRecommendations>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AppWhitelistingPutGroupData {
#[serde(rename = "enforcementMode", default, skip_serializing_if = "Option::is_none")]
pub enforcement_mode: Option<EnforcementMode>,
#[serde(rename = "protectionMode", default, skip_serializing_if = "Option::is_none")]
pub protection_mode: Option<ProtectionMode>,
#[serde(rename = "vmRecommendations", default, skip_serializing_if = "Option::is_none")]
pub vm_recommendations: Option<VmRecommendations>,
#[serde(rename = "pathRecommendations", default, skip_serializing_if = "Option::is_none")]
pub path_recommendations: Option<PathRecommendations>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum ConfigurationStatus {
Configured,
NotConfigured,
InProgress,
Failed,
NoStatus,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum EnforcementMode {
Audit,
Enforce,
None,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum EnforcementSupport {
Supported,
NotSupported,
Unknown,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ProtectionMode {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub exe: Option<EnforcementMode>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub msi: Option<EnforcementMode>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub script: Option<EnforcementMode>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub executable: Option<EnforcementMode>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum RecommendationStatus {
Recommended,
NotRecommended,
NotAvailable,
NoStatus,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum RecommendationAction {
Recommended,
Add,
Remove,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum RecommendationType {
File,
FileHash,
PublisherSignature,
ProductSignature,
BinarySignature,
VersionAndAboveSignature,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum AppWhitelistingIssue {
ViolationsAudited,
ViolationsBlocked,
MsiAndScriptViolationsAudited,
MsiAndScriptViolationsBlocked,
ExecutableViolationsAudited,
RulesViolatedManually,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum FileType {
Exe,
Dll,
Msi,
Script,
Executable,
Unknown,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum SourceSystem {
#[serde(rename = "Azure_AppLocker")]
AzureAppLocker,
#[serde(rename = "Azure_AuditD")]
AzureAuditD,
#[serde(rename = "NonAzure_AppLocker")]
NonAzureAppLocker,
#[serde(rename = "NonAzure_AuditD")]
NonAzureAuditD,
None,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AppWhitelistingIssueSummary {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub issue: Option<AppWhitelistingIssue>,
#[serde(rename = "numberOfVms", default, skip_serializing_if = "Option::is_none")]
pub number_of_vms: Option<f64>,
}
pub type AppWhitelistingIssuesSummaries = Vec<AppWhitelistingIssueSummary>;
pub type VmRecommendations = Vec<VmRecommendation>;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct VmRecommendation {
#[serde(rename = "configurationStatus", default, skip_serializing_if = "Option::is_none")]
pub configuration_status: Option<ConfigurationStatus>,
#[serde(rename = "recommendationAction", default, skip_serializing_if = "Option::is_none")]
pub recommendation_action: Option<RecommendationAction>,
#[serde(rename = "resourceId", default, skip_serializing_if = "Option::is_none")]
pub resource_id: Option<VmResourceId>,
#[serde(rename = "enforcementSupport", default, skip_serializing_if = "Option::is_none")]
pub enforcement_support: Option<EnforcementSupport>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct PublisherInfo {
#[serde(rename = "publisherName", default, skip_serializing_if = "Option::is_none")]
pub publisher_name: Option<String>,
#[serde(rename = "productName", default, skip_serializing_if = "Option::is_none")]
pub product_name: Option<String>,
#[serde(rename = "binaryName", default, skip_serializing_if = "Option::is_none")]
pub binary_name: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct UserRecommendation {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub username: Option<String>,
#[serde(rename = "recommendationAction", default, skip_serializing_if = "Option::is_none")]
pub recommendation_action: Option<RecommendationAction>,
}
pub type PathRecommendations = Vec<PathRecommendation>;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct PathRecommendation {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub path: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub action: Option<RecommendationAction>,
#[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
pub type_: Option<RecommendationType>,
#[serde(rename = "publisherInfo", default, skip_serializing_if = "Option::is_none")]
pub publisher_info: Option<PublisherInfo>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub common: Option<bool>,
#[serde(rename = "userSids", default, skip_serializing_if = "Vec::is_empty")]
pub user_sids: Vec<String>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub usernames: Vec<UserRecommendation>,
#[serde(rename = "fileType", default, skip_serializing_if = "Option::is_none")]
pub file_type: Option<FileType>,
#[serde(rename = "configurationStatus", default, skip_serializing_if = "Option::is_none")]
pub configuration_status: Option<ConfigurationStatus>,
}
pub type GroupResourceId = String;
pub type VmResourceId = String;
pub type AppWhitelistingResourceType = String;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct DiscoveredSecuritySolutionList {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub value: Vec<DiscoveredSecuritySolution>,
#[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
pub next_link: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct DiscoveredSecuritySolution {
#[serde(flatten)]
pub resource: Resource,
#[serde(flatten)]
pub location: Location,
pub properties: DiscoveredSecuritySolutionProperties,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct DiscoveredSecuritySolutionProperties {
#[serde(rename = "securityFamily")]
pub security_family: discovered_security_solution_properties::SecurityFamily,
pub offer: String,
pub publisher: String,
pub sku: String,
}
pub mod discovered_security_solution_properties {
use super::*;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum SecurityFamily {
Waf,
Ngfw,
SaasWaf,
Va,
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ExternalSecuritySolutionList {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub value: Vec<ExternalSecuritySolution>,
#[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
pub next_link: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ExternalSecuritySolution {
#[serde(flatten)]
pub resource: Resource,
#[serde(flatten)]
pub external_security_solution_kind: ExternalSecuritySolutionKind,
#[serde(flatten)]
pub location: Location,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct CefExternalSecuritySolution {
#[serde(flatten)]
pub external_security_solution: ExternalSecuritySolution,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub properties: Option<CefSolutionProperties>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AtaExternalSecuritySolution {
#[serde(flatten)]
pub external_security_solution: ExternalSecuritySolution,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub properties: Option<AtaSolutionProperties>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AadExternalSecuritySolution {
#[serde(flatten)]
pub external_security_solution: ExternalSecuritySolution,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub properties: Option<AadSolutionProperties>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ExternalSecuritySolutionKind {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub kind: Option<external_security_solution_kind::Kind>,
}
pub mod external_security_solution_kind {
use super::*;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum Kind {
#[serde(rename = "CEF")]
Cef,
#[serde(rename = "ATA")]
Ata,
#[serde(rename = "AAD")]
Aad,
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ExternalSecuritySolutionProperties {
#[serde(rename = "deviceVendor", default, skip_serializing_if = "Option::is_none")]
pub device_vendor: Option<String>,
#[serde(rename = "deviceType", default, skip_serializing_if = "Option::is_none")]
pub device_type: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub workspace: Option<ConnectedWorkspace>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ConnectedWorkspace {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AadConnectivityState {
#[serde(rename = "connectivityState", default, skip_serializing_if = "Option::is_none")]
pub connectivity_state: Option<aad_connectivity_state::ConnectivityState>,
}
pub mod aad_connectivity_state {
use super::*;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum ConnectivityState {
Discovered,
NotLicensed,
Connected,
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AadSolutionProperties {
#[serde(flatten)]
pub external_security_solution_properties: ExternalSecuritySolutionProperties,
#[serde(flatten)]
pub aad_connectivity_state: AadConnectivityState,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct CefSolutionProperties {
#[serde(flatten)]
pub external_security_solution_properties: ExternalSecuritySolutionProperties,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub hostname: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub agent: Option<String>,
#[serde(rename = "lastEventReceived", default, skip_serializing_if = "Option::is_none")]
pub last_event_received: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AtaSolutionProperties {
#[serde(flatten)]
pub external_security_solution_properties: ExternalSecuritySolutionProperties,
#[serde(rename = "lastEventReceived", default, skip_serializing_if = "Option::is_none")]
pub last_event_received: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct JitNetworkAccessPoliciesList {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub value: Vec<JitNetworkAccessPolicy>,
#[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
pub next_link: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct JitNetworkAccessPolicy {
#[serde(flatten)]
pub resource: Resource,
#[serde(flatten)]
pub kind: Kind,
#[serde(flatten)]
pub location: Location,
pub properties: JitNetworkAccessPolicyProperties,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct JitNetworkAccessPolicyProperties {
#[serde(rename = "virtualMachines")]
pub virtual_machines: Vec<JitNetworkAccessPolicyVirtualMachine>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub requests: Vec<JitNetworkAccessRequest>,
#[serde(rename = "provisioningState", default, skip_serializing_if = "Option::is_none")]
pub provisioning_state: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct JitNetworkAccessPolicyVirtualMachine {
pub id: String,
pub ports: Vec<JitNetworkAccessPortRule>,
#[serde(rename = "publicIpAddress", default, skip_serializing_if = "Option::is_none")]
pub public_ip_address: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct JitNetworkAccessPortRule {
pub number: PortNumber,
pub protocol: jit_network_access_port_rule::Protocol,
#[serde(rename = "allowedSourceAddressPrefix", default, skip_serializing_if = "Option::is_none")]
pub allowed_source_address_prefix: Option<String>,
#[serde(rename = "allowedSourceAddressPrefixes", default, skip_serializing_if = "Vec::is_empty")]
pub allowed_source_address_prefixes: Vec<String>,
#[serde(rename = "maxRequestAccessDuration")]
pub max_request_access_duration: String,
}
pub mod jit_network_access_port_rule {
use super::*;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum Protocol {
#[serde(rename = "TCP")]
Tcp,
#[serde(rename = "UDP")]
Udp,
#[serde(rename = "*")]
U2a,
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct JitNetworkAccessRequest {
#[serde(rename = "virtualMachines")]
pub virtual_machines: Vec<JitNetworkAccessRequestVirtualMachine>,
#[serde(rename = "startTimeUtc")]
pub start_time_utc: String,
pub requestor: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub justification: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct JitNetworkAccessRequestVirtualMachine {
pub id: String,
pub ports: Vec<JitNetworkAccessRequestPort>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct JitNetworkAccessRequestPort {
pub number: PortNumber,
#[serde(rename = "allowedSourceAddressPrefix", default, skip_serializing_if = "Option::is_none")]
pub allowed_source_address_prefix: Option<String>,
#[serde(rename = "allowedSourceAddressPrefixes", default, skip_serializing_if = "Vec::is_empty")]
pub allowed_source_address_prefixes: Vec<String>,
#[serde(rename = "endTimeUtc")]
pub end_time_utc: String,
pub status: jit_network_access_request_port::Status,
#[serde(rename = "statusReason")]
pub status_reason: jit_network_access_request_port::StatusReason,
#[serde(rename = "mappedPort", default, skip_serializing_if = "Option::is_none")]
pub mapped_port: Option<i64>,
}
pub mod jit_network_access_request_port {
use super::*;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum Status {
Revoked,
Initiated,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum StatusReason {
Expired,
UserRequested,
NewerRequestInitiated,
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct JitNetworkAccessPolicyInitiateRequest {
#[serde(rename = "virtualMachines")]
pub virtual_machines: Vec<JitNetworkAccessPolicyInitiateVirtualMachine>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub justification: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct JitNetworkAccessPolicyInitiateVirtualMachine {
pub id: String,
pub ports: Vec<JitNetworkAccessPolicyInitiatePort>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct JitNetworkAccessPolicyInitiatePort {
pub number: PortNumber,
#[serde(rename = "allowedSourceAddressPrefix", default, skip_serializing_if = "Option::is_none")]
pub allowed_source_address_prefix: Option<String>,
#[serde(rename = "endTimeUtc")]
pub end_time_utc: String,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct OperationList {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub value: Vec<Operation>,
#[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
pub next_link: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Operation {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub origin: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub display: Option<OperationDisplay>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct OperationDisplay {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub provider: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub resource: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub operation: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct SecurityTaskList {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub value: Vec<SecurityTask>,
#[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
pub next_link: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct SecurityTask {
#[serde(flatten)]
pub resource: Resource,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub properties: Option<SecurityTaskProperties>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct SecurityTaskProperties {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
#[serde(rename = "creationTimeUtc", default, skip_serializing_if = "Option::is_none")]
pub creation_time_utc: Option<String>,
#[serde(rename = "securityTaskParameters", default, skip_serializing_if = "Option::is_none")]
pub security_task_parameters: Option<SecurityTaskParameters>,
#[serde(rename = "lastStateChangeTimeUtc", default, skip_serializing_if = "Option::is_none")]
pub last_state_change_time_utc: Option<String>,
#[serde(rename = "subState", default, skip_serializing_if = "Option::is_none")]
pub sub_state: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct SecurityTaskParameters {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct TopologyList {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub value: Vec<TopologyResource>,
#[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
pub next_link: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct TopologyResource {
#[serde(flatten)]
pub resource: Resource,
#[serde(flatten)]
pub location: Location,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub properties: Option<TopologyResourceProperties>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct TopologyResourceProperties {
#[serde(rename = "calculatedDateTime", default, skip_serializing_if = "Option::is_none")]
pub calculated_date_time: Option<String>,
#[serde(rename = "topologyResources", default, skip_serializing_if = "Vec::is_empty")]
pub topology_resources: Vec<TopologySingleResource>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct TopologySingleResource {
#[serde(rename = "resourceId", default, skip_serializing_if = "Option::is_none")]
pub resource_id: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub severity: Option<String>,
#[serde(rename = "recommendationsExist", default, skip_serializing_if = "Option::is_none")]
pub recommendations_exist: Option<bool>,
#[serde(rename = "networkZones", default, skip_serializing_if = "Option::is_none")]
pub network_zones: Option<String>,
#[serde(rename = "topologyScore", default, skip_serializing_if = "Option::is_none")]
pub topology_score: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub location: Option<String>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub parents: Vec<TopologySingleResourceParent>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub children: Vec<TopologySingleResourceChild>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct TopologySingleResourceParent {
#[serde(rename = "resourceId", default, skip_serializing_if = "Option::is_none")]
pub resource_id: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct TopologySingleResourceChild {
#[serde(rename = "resourceId", default, skip_serializing_if = "Option::is_none")]
pub resource_id: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct CloudError {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub error: Option<CloudErrorBody>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct CloudErrorBody {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub code: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub target: Option<String>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub details: Vec<CloudErrorBody>,
#[serde(rename = "additionalInfo", default, skip_serializing_if = "Vec::is_empty")]
pub additional_info: Vec<ErrorAdditionalInfo>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ErrorAdditionalInfo {
#[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub info: Option<serde_json::Value>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Resource {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Location {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub location: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Kind {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub kind: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AscLocationList {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub value: Vec<AscLocation>,
#[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
pub next_link: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AscLocation {
#[serde(flatten)]
pub resource: Resource,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub properties: Option<AscLocationProperties>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AscLocationProperties {}
|
use crate::core::clients::{ServiceType, StorageAccountClient};
use bytes::Bytes;
use http::method::Method;
use http::request::{Builder, Request};
use std::sync::Arc;
pub trait AsStorageClient {
fn as_storage_client(&self) -> Arc<StorageClient>;
}
impl AsStorageClient for Arc<StorageAccountClient> {
fn as_storage_client(&self) -> Arc<StorageClient> {
StorageClient::new(self.clone())
}
}
#[derive(Debug, Clone)]
pub struct StorageClient {
storage_account_client: Arc<StorageAccountClient>,
}
impl StorageClient {
pub(crate) fn new(storage_account_client: Arc<StorageAccountClient>) -> Arc<Self> {
Arc::new(Self {
storage_account_client,
})
}
#[allow(dead_code)]
pub fn storage_account_client(&self) -> &StorageAccountClient {
self.storage_account_client.as_ref()
}
#[allow(dead_code)]
pub(crate) fn http_client(&self) -> &dyn azure_core::HttpClient {
self.storage_account_client.http_client()
}
fn url_with_segments<'a, I>(mut url: url::Url, segments: I) -> Result<url::Url, url::ParseError>
where
I: IntoIterator<Item = &'a str>,
{
{
let mut segs = url
.path_segments_mut()
.map_err(|_| url::ParseError::SetHostOnCannotBeABaseUrl)?;
for segment in segments.into_iter() {
segs.push(segment);
}
}
Ok(url)
}
pub(crate) fn blob_url_with_segments<'a, I>(
&'a self,
segments: I,
) -> Result<url::Url, url::ParseError>
where
I: IntoIterator<Item = &'a str>,
{
Self::url_with_segments(
self.storage_account_client.blob_storage_url().to_owned(),
segments,
)
}
pub fn queue_url_with_segments<'a, I>(
&'a self,
segments: I,
) -> Result<url::Url, url::ParseError>
where
I: IntoIterator<Item = &'a str>,
{
Self::url_with_segments(
self.storage_account_client.queue_storage_url().to_owned(),
segments,
)
}
#[cfg(feature = "account")]
pub fn get_account_information(
&self,
) -> crate::account::requests::GetAccountInformationBuilder {
crate::account::requests::GetAccountInformationBuilder::new(self)
}
pub fn find_blobs_by_tags(&self) -> crate::account::requests::FindBlobsByTagsBuilder {
crate::account::requests::FindBlobsByTagsBuilder::new(self)
}
#[cfg(feature = "blob")]
pub fn list_containers(&self) -> crate::container::requests::ListContainersBuilder {
crate::container::requests::ListContainersBuilder::new(self)
}
#[allow(dead_code)]
pub fn prepare_request(
&self,
url: &str,
method: &Method,
http_header_adder: &dyn Fn(Builder) -> Builder,
request_body: Option<Bytes>,
) -> crate::Result<(Request<Bytes>, url::Url)> {
self.storage_account_client.prepare_request(
url,
method,
http_header_adder,
ServiceType::Blob,
request_body,
)
}
}
|
#![doc = "generated by AutoRust 0.1.0"]
#![allow(non_camel_case_types)]
#![allow(unused_imports)]
use serde::{Deserialize, Serialize};
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AzureResource {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub location: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub tags: Option<serde_json::Value>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ActivityLogAlertResource {
#[serde(flatten)]
pub azure_resource: AzureResource,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub properties: Option<AlertRuleProperties>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AlertRuleList {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub value: Vec<ActivityLogAlertResource>,
#[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
pub next_link: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AlertRuleProperties {
pub scopes: Vec<String>,
pub condition: AlertRuleAllOfCondition,
pub actions: ActionList,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AlertRuleAllOfCondition {
#[serde(rename = "allOf")]
pub all_of: Vec<AlertRuleAnyOfOrLeafCondition>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AlertRuleAnyOfOrLeafCondition {
#[serde(flatten)]
pub alert_rule_leaf_condition: AlertRuleLeafCondition,
#[serde(rename = "anyOf", default, skip_serializing_if = "Vec::is_empty")]
pub any_of: Vec<AlertRuleLeafCondition>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AlertRuleLeafCondition {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub field: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub equals: Option<String>,
#[serde(rename = "containsAny", default, skip_serializing_if = "Vec::is_empty")]
pub contains_any: Vec<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ActionList {
#[serde(rename = "actionGroups", default, skip_serializing_if = "Vec::is_empty")]
pub action_groups: Vec<ActionGroup>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ActionGroup {
#[serde(rename = "actionGroupId")]
pub action_group_id: String,
#[serde(rename = "webhookProperties", default, skip_serializing_if = "Option::is_none")]
pub webhook_properties: Option<serde_json::Value>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AlertRulePatchObject {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub tags: Option<serde_json::Value>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub properties: Option<AlertRulePatchProperties>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AlertRulePatchProperties {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ErrorResponse {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub code: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
}
|
use std::process::Command;
use crate::revision_shortcut::RevisionShortcut;
use crate::select::{Entry, State};
use crate::version_control_actions::{handle_command, VersionControlActions};
fn str_to_state(s: &str) -> State {
match s {
"?" => State::Untracked,
"M" => State::Modified,
"A" => State::Added,
"D" => State::Deleted,
"R" => State::Renamed,
"C" => State::Copied,
"U" => State::Unmerged,
_ => State::Unmodified,
}
}
pub struct GitActions {
pub current_dir: String,
pub revision_shortcut: RevisionShortcut,
}
impl GitActions {
fn command(&self) -> Command {
let mut command = Command::new("git");
command.current_dir(&self.current_dir[..]);
command
}
}
impl VersionControlActions for GitActions {
fn set_root(&mut self) -> Result<(), String> {
let mut command = self.command();
let dir =
handle_command(command.args(&["rev-parse", "--show-toplevel"]))?;
let dir = dir
.lines()
.next()
.expect("Root directory is an empty string");
self.current_dir = dir.to_owned();
Ok(())
}
fn get_root(&self) -> &str {
&self.current_dir[..]
}
fn get_current_changed_files(&mut self) -> Result<Vec<Entry>, String> {
let output = handle_command(self.command().args(&["status", "-z"]))?;
let files = output
.trim()
.split('\0')
.map(|e| e.trim())
.filter(|e| e.len() > 2)
.map(|e| {
let (state, filename) = e.split_at(2);
Entry {
filename: String::from(filename.trim()),
selected: false,
state: str_to_state(&state[..1]),
}
})
.collect();
Ok(files)
}
fn get_revision_changed_files(
&mut self,
target: &str,
) -> Result<Vec<Entry>, String> {
let target = self.revision_shortcut.get_hash(target).unwrap_or(target);
let output = handle_command(
self.command()
.arg("diff-tree")
.arg("--no-commit-id")
.arg("--name-status")
.arg("-z")
.arg("-r")
.arg(target),
)?;
let state_iter = output.split('\0').map(|e| e.trim()).step_by(2);
let filename_iter =
output.split('\0').map(|e| e.trim()).skip(1).step_by(2);
let files = state_iter
.zip(filename_iter)
.map(|(s, f)| Entry {
filename: String::from(f),
selected: false,
state: str_to_state(s),
})
.collect();
Ok(files)
}
fn version(&mut self) -> Result<String, String> {
handle_command(self.command().arg("--version"))
}
fn status(&mut self) -> Result<String, String> {
handle_command(self.command().args(&[
"-c",
"color.status=always",
"status",
]))
}
fn current_export(&mut self) -> Result<String, String> {
handle_command(self.command().args(&["show", "--color"]))
}
fn log(&mut self, count: u32) -> Result<String, String> {
let count_str = format!("-{}", count);
let hashes_output = handle_command(
self.command()
.arg("log")
.arg("--all")
.arg("--format=format:%h")
.arg(&count_str),
)?;
let hashes: Vec<_> = hashes_output
.split_whitespace()
.take(RevisionShortcut::max())
.map(String::from)
.collect();
self.revision_shortcut.update_hashes(hashes);
let template = "--format=format:%C(auto,yellow)%h %C(auto,blue)%>(10,trunc)%ad %C(auto,green)%<(10,trunc)%aN %C(auto)%d %C(auto,reset)%s";
let mut output = handle_command(
self.command()
.arg("log")
.arg("--all")
.arg("--decorate")
.arg("--oneline")
.arg("--graph")
.arg(&count_str)
.arg("--color")
.arg(template)
.arg("--date=short"),
)?;
self.revision_shortcut.replace_occurrences(&mut output);
Ok(output)
}
fn current_diff_all(&mut self) -> Result<String, String> {
handle_command(self.command().args(&["diff", "--color"]))
}
fn current_diff_selected(
&mut self,
entries: &Vec<Entry>,
) -> Result<String, String> {
let mut command = self.command();
command.arg("diff").arg("--color").arg("--");
for e in entries.iter() {
if e.selected {
command.arg(&e.filename);
}
}
handle_command(&mut command)
}
fn revision_changes(&mut self, target: &str) -> Result<String, String> {
let target = self.revision_shortcut.get_hash(target).unwrap_or(target);
handle_command(
self.command()
.arg("diff-tree")
.arg("--no-commit-id")
.arg("--name-status")
.arg("-r")
.arg(target)
.arg("--color"),
)
}
fn revision_diff_all(&mut self, target: &str) -> Result<String, String> {
let target = self.revision_shortcut.get_hash(target).unwrap_or(target);
let mut parents = String::from(target);
parents.push_str("^@");
handle_command(
self.command()
.arg("diff")
.arg(parents)
.arg(target)
.arg("--color"),
)
}
fn revision_diff_selected(
&mut self,
target: &str,
entries: &Vec<Entry>,
) -> Result<String, String> {
let target = self.revision_shortcut.get_hash(target).unwrap_or(target);
let mut parents = String::from(target);
parents.push_str("^@");
let mut command = self.command();
command
.arg("diff")
.arg("--color")
.arg(parents)
.arg(target)
.arg("--");
for e in entries.iter() {
if e.selected {
command.arg(&e.filename);
}
}
handle_command(&mut command)
}
fn commit_all(&mut self, message: &str) -> Result<String, String> {
handle_command(self.command().args(&["add", "--all"]))?;
handle_command(self.command().arg("commit").arg("-m").arg(message))
}
fn commit_selected(
&mut self,
message: &str,
entries: &Vec<Entry>,
) -> Result<String, String> {
for e in entries.iter() {
if e.selected {
handle_command(
self.command().arg("add").arg("--").arg(&e.filename),
)?;
}
}
handle_command(self.command().arg("commit").arg("-m").arg(message))
}
fn revert_all(&mut self) -> Result<String, String> {
let mut output = String::new();
output.push_str(
&handle_command(self.command().args(&["reset", "--hard"]))?[..],
);
output.push('\n');
output.push_str(
&handle_command(self.command().args(&["clean", "-df"]))?[..],
);
Ok(output)
}
fn revert_selected(
&mut self,
entries: &Vec<Entry>,
) -> Result<String, String> {
let mut output = String::new();
for e in entries.iter() {
if !e.selected {
continue;
}
match e.state {
State::Untracked => {
handle_command(
self.command()
.arg("clean")
.arg("-f")
.arg("--")
.arg(&e.filename),
)?;
}
State::Added => {
handle_command(
self.command()
.arg("rm")
.arg("-f")
.arg("--")
.arg(&e.filename),
)?;
}
_ => {
let o = handle_command(
self.command()
.arg("checkout")
.arg("--")
.arg(&e.filename),
)?;
output.push_str(&o[..]);
}
}
}
Ok(output)
}
fn update(&mut self, target: &str) -> Result<String, String> {
let target = self.revision_shortcut.get_hash(target).unwrap_or(target);
handle_command(self.command().arg("checkout").arg(target))
}
fn merge(&mut self, target: &str) -> Result<String, String> {
let target = self.revision_shortcut.get_hash(target).unwrap_or(target);
handle_command(self.command().arg("merge").arg(target))
}
fn conflicts(&mut self) -> Result<String, String> {
handle_command(self.command().args(&[
"diff",
"--name-only",
"--diff-filter=U",
]))
}
fn take_other(&mut self) -> Result<String, String> {
handle_command(self.command().args(&["checkout", ".", "--theirs"]))
}
fn take_local(&mut self) -> Result<String, String> {
handle_command(self.command().args(&["checkout", ".", "--ours"]))
}
fn fetch(&mut self) -> Result<String, String> {
handle_command(self.command().args(&["fetch", "--all"]))
}
fn pull(&mut self) -> Result<String, String> {
handle_command(self.command().args(&["pull", "--all"]))
}
fn push(&mut self) -> Result<String, String> {
handle_command(self.command().arg("push"))
}
fn create_tag(&mut self, name: &str) -> Result<String, String> {
let mut output = String::new();
output.push_str(
&handle_command(self.command().arg("tag").arg(name).arg("-f"))?[..],
);
output.push_str(
&handle_command(
self.command().arg("push").arg("origin").arg(name),
)?[..],
);
Ok(output)
}
fn list_branches(&mut self) -> Result<String, String> {
handle_command(self.command().args(&["branch", "--all", "--color"]))
}
fn create_branch(&mut self, name: &str) -> Result<String, String> {
let mut output = String::new();
output.push_str(
&handle_command(self.command().arg("branch").arg(name))?[..],
);
output.push('\n');
output.push_str(&self.update(name)?[..]);
output.push('\n');
output.push_str(
&handle_command(
self.command()
.arg("push")
.arg("--set-upstream")
.arg("origin")
.arg(name),
)?[..],
);
Ok(output)
}
fn close_branch(&mut self, name: &str) -> Result<String, String> {
let mut output = String::new();
output.push_str(
&handle_command(self.command().arg("branch").arg("-d").arg(name))?
[..],
);
output.push('\n');
output.push_str(
&handle_command(
self.command().arg("push").arg("-d").arg("origin").arg(name),
)?[..],
);
Ok(output)
}
}
|
import std::sys;
#[test]
fn last_os_error() { log sys::rustrt::last_os_error(); }
|
use serde::{Serialize, Deserialize};
use std::collections::HashMap;
use serde_json::Value;
use anyhow::Result;
#[derive(Debug, Serialize, Deserialize)]
struct Item {
a: String,
b: i32
}
#[derive(Debug, Serialize, Deserialize)]
struct Test {
pub name: String,
#[serde(rename="$value")]
pub items: Vec<Item>,
// #[serde(flatten)]
// extra: HashMap<String, Value>
}
fn value_to_xml(value: &Value) -> Result<String> {
match value {
Value::Null => Ok("".to_string()),
Value::Bool(b) => Ok(b.to_string()),
Value::Number(n) => Ok(n.to_string()),
Value::String(s) => Ok(s.clone()),
Value::Array(a) => array_to_xml(a),
Value::Object(o) => obj_to_xml(o),
}
}
fn array_to_xml(a: &Vec<Value>) -> Result<String> {
let mut s: String = "".to_string();
for v in a {
s.push_str(value_to_xml(v)?.as_str());
}
Ok(s)
}
fn obj_to_xml(obj: &serde_json::Map<String, Value>) -> Result<String> {
let mut s: String = "".to_string();
for (key, value) in obj {
s.push_str(format!("<{}>{}</{}>", key, value_to_xml(value)?, key).as_str());
}
Ok(s)
}
fn main() -> anyhow::Result<()> {
let data = r#"
{
"name": "Vasya",
"items": [
{ "a": "test", "b": 25 },
{ "a": "jest", "b": 77 }
],
"kobra": "fdsfdsfsdfdsf",
"tvers": [
{ "rrr": "x" },
{ "vvv": "y" }
],
"qwert": {
"cvcvc" : 1,
"sdsdfsdf": true
}
}
"#;
let t: serde_json::Map<String, Value> = serde_json::from_str(data)?;
let xml = format!("<div>{}</div>", obj_to_xml(&t)?);
println!("{}", xml);
Ok(())
}
|
use crate::grammar::ast::{BinaryOp, Expression};
use crate::grammar::model::WrightInput;
use crate::grammar::parsers::expression::binary_expression::primary::bitshift::{
bitshift, bitshift_primary,
};
use crate::grammar::parsers::expression::binary_expression::primary::parser_left;
use crate::grammar::tracing::parsers::alt;
use crate::grammar::tracing::trace_result;
use nom::IResult;
/// Parser for sub expressions of a relational expression.
pub fn relational_primary<I: WrightInput>(input: I) -> IResult<I, Expression<I>> {
let trace = "BinaryExpr::relational_primary";
trace_result(
trace,
alt((bitshift, bitshift_primary))(input.trace_start_clone(trace)),
)
}
/// Parse a relational expression.
pub fn relational<I: WrightInput>(input: I) -> IResult<I, Expression<I>> {
let trace = "BinaryExpr::relational";
trace_result(
trace,
parser_left(relational_primary, BinaryOp::parse_relational_operator)(
input.trace_start_clone(trace),
),
)
}
|
fn main(){
let mut s1 = String::from("hello");
let s2 = &mut s1;
s2.push_str("world!\n"); //disallowed
drop(s2);
s1.push_str("world!"); //ok
println!("String is {}",s1);//prints updated s1
}
|
//! [CommonNetworkRelativeLink](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-shllink/23bb5877-e3dd-4799-9f50-79f05f938537) related structs
use winparsingtools::{
utils,
traits::Path
};
use byteorder::{LittleEndian, ReadBytesExt};
use std::io::{Cursor, Read, Result, Seek, SeekFrom};
use serde::Serialize;
#[derive(Debug, Serialize)]
pub enum CommonNetworkRelativeLinkFlags {
ValidDevice,
ValidNetType,
}
#[derive(Debug, Serialize)]
pub enum NetworkProviderType {
WNNC_NET_MSNET,
WNNC_NET_SMB_LANMAN,
WNNC_NET_NETWARE,
WNNC_NET_VINES,
WNNC_NET_10NET,
WNNC_NET_LOCUS,
WNNC_NET_SUN_PC_NFS,
WNNC_NET_LANSTEP,
WNNC_NET_9TILES,
WNNC_NET_LANTASTIC,
WNNC_NET_AS400,
WNNC_NET_FTP_NFS,
WNNC_NET_PATHWORKS,
WNNC_NET_LIFENET,
WNNC_NET_POWERLAN,
WNNC_NET_BWNFS,
WNNC_NET_COGENT,
WNNC_NET_FARALLON,
WNNC_NET_APPLETALK,
WNNC_NET_INTERGRAPH,
WNNC_NET_SYMFONET,
WNNC_NET_CLEARCASE,
WNNC_NET_FRONTIER,
WNNC_NET_BMC,
WNNC_NET_DCE,
WNNC_NET_AVID,
WNNC_NET_DOCUSPACE,
WNNC_NET_MANGOSOFT,
WNNC_NET_SERNET,
WNNC_NET_RIVERFRONT1,
WNNC_NET_RIVERFRONT2,
WNNC_NET_DECORB,
WNNC_NET_PROTSTOR,
WNNC_NET_FJ_REDIR,
WNNC_NET_DISTINCT,
WNNC_NET_TWINS,
WNNC_NET_RDR2SAMPLE,
WNNC_NET_CSC,
WNNC_NET_3IN1,
WNNC_NET_EXTENDNET,
WNNC_NET_STAC,
WNNC_NET_FOXBAT,
WNNC_NET_YAHOO,
WNNC_NET_EXIFS,
WNNC_NET_DAV,
WNNC_NET_KNOWARE,
WNNC_NET_OBJECT_DIRE,
WNNC_NET_MASFAX,
WNNC_NET_HOB_NFS,
WNNC_NET_SHIVA,
WNNC_NET_IBMAL,
WNNC_NET_LOCK,
WNNC_NET_TERMSRV,
WNNC_NET_SRT,
WNNC_NET_QUINCY,
WNNC_NET_OPENAFS,
WNNC_NET_AVID1,
WNNC_NET_DFS,
WNNC_NET_KWNP,
WNNC_NET_ZENWORKS,
WNNC_NET_DRIVEONWEB,
WNNC_NET_VMWARE,
WNNC_NET_RSFX,
WNNC_NET_MFILES,
WNNC_NET_MS_NFS,
WNNC_NET_GOOGLE,
WNNC_NET_NDFS,
WNNC_NET_DOCUSHARE,
WNNC_CRED_MANAGER,
UNKNOWN,
}
impl From<u32> for NetworkProviderType {
fn from(num: u32) -> Self {
match num {
0x00010000 => NetworkProviderType::WNNC_NET_MSNET,
0x00020000 => NetworkProviderType::WNNC_NET_SMB_LANMAN,
0x00030000 => NetworkProviderType::WNNC_NET_NETWARE,
0x00040000 => NetworkProviderType::WNNC_NET_VINES,
0x00050000 => NetworkProviderType::WNNC_NET_10NET,
0x00060000 => NetworkProviderType::WNNC_NET_LOCUS,
0x00070000 => NetworkProviderType::WNNC_NET_SUN_PC_NFS,
0x00080000 => NetworkProviderType::WNNC_NET_LANSTEP,
0x00090000 => NetworkProviderType::WNNC_NET_9TILES,
0x000A0000 => NetworkProviderType::WNNC_NET_LANTASTIC,
0x000B0000 => NetworkProviderType::WNNC_NET_AS400,
0x000C0000 => NetworkProviderType::WNNC_NET_FTP_NFS,
0x000D0000 => NetworkProviderType::WNNC_NET_PATHWORKS,
0x000E0000 => NetworkProviderType::WNNC_NET_LIFENET,
0x000F0000 => NetworkProviderType::WNNC_NET_POWERLAN,
0x00100000 => NetworkProviderType::WNNC_NET_BWNFS,
0x00110000 => NetworkProviderType::WNNC_NET_COGENT,
0x00120000 => NetworkProviderType::WNNC_NET_FARALLON,
0x00130000 => NetworkProviderType::WNNC_NET_APPLETALK,
0x00140000 => NetworkProviderType::WNNC_NET_INTERGRAPH,
0x00150000 => NetworkProviderType::WNNC_NET_SYMFONET,
0x00160000 => NetworkProviderType::WNNC_NET_CLEARCASE,
0x00170000 => NetworkProviderType::WNNC_NET_FRONTIER,
0x00180000 => NetworkProviderType::WNNC_NET_BMC,
0x00190000 => NetworkProviderType::WNNC_NET_DCE,
0x001A0000 => NetworkProviderType::WNNC_NET_AVID,
0x001B0000 => NetworkProviderType::WNNC_NET_DOCUSPACE,
0x001C0000 => NetworkProviderType::WNNC_NET_MANGOSOFT,
0x001D0000 => NetworkProviderType::WNNC_NET_SERNET,
0x001E0000 => NetworkProviderType::WNNC_NET_RIVERFRONT1,
0x001F0000 => NetworkProviderType::WNNC_NET_RIVERFRONT2,
0x00200000 => NetworkProviderType::WNNC_NET_DECORB,
0x00210000 => NetworkProviderType::WNNC_NET_PROTSTOR,
0x00220000 => NetworkProviderType::WNNC_NET_FJ_REDIR,
0x00230000 => NetworkProviderType::WNNC_NET_DISTINCT,
0x00240000 => NetworkProviderType::WNNC_NET_TWINS,
0x00250000 => NetworkProviderType::WNNC_NET_RDR2SAMPLE,
0x00260000 => NetworkProviderType::WNNC_NET_CSC,
0x00270000 => NetworkProviderType::WNNC_NET_3IN1,
0x00290000 => NetworkProviderType::WNNC_NET_EXTENDNET,
0x002A0000 => NetworkProviderType::WNNC_NET_STAC,
0x002B0000 => NetworkProviderType::WNNC_NET_FOXBAT,
0x002C0000 => NetworkProviderType::WNNC_NET_YAHOO,
0x002D0000 => NetworkProviderType::WNNC_NET_EXIFS,
0x002E0000 => NetworkProviderType::WNNC_NET_DAV,
0x002F0000 => NetworkProviderType::WNNC_NET_KNOWARE,
0x00300000 => NetworkProviderType::WNNC_NET_OBJECT_DIRE,
0x00310000 => NetworkProviderType::WNNC_NET_MASFAX,
0x00320000 => NetworkProviderType::WNNC_NET_HOB_NFS,
0x00330000 => NetworkProviderType::WNNC_NET_SHIVA,
0x00340000 => NetworkProviderType::WNNC_NET_IBMAL,
0x00350000 => NetworkProviderType::WNNC_NET_LOCK,
0x00360000 => NetworkProviderType::WNNC_NET_TERMSRV,
0x00370000 => NetworkProviderType::WNNC_NET_SRT,
0x00380000 => NetworkProviderType::WNNC_NET_QUINCY,
0x00390000 => NetworkProviderType::WNNC_NET_OPENAFS,
0x003A0000 => NetworkProviderType::WNNC_NET_AVID1,
0x003B0000 => NetworkProviderType::WNNC_NET_DFS,
0x003C0000 => NetworkProviderType::WNNC_NET_KWNP,
0x003D0000 => NetworkProviderType::WNNC_NET_ZENWORKS,
0x003E0000 => NetworkProviderType::WNNC_NET_DRIVEONWEB,
0x003F0000 => NetworkProviderType::WNNC_NET_VMWARE,
0x00400000 => NetworkProviderType::WNNC_NET_RSFX,
0x00410000 => NetworkProviderType::WNNC_NET_MFILES,
0x00420000 => NetworkProviderType::WNNC_NET_MS_NFS,
0x00430000 => NetworkProviderType::WNNC_NET_GOOGLE,
0x00440000 => NetworkProviderType::WNNC_NET_NDFS,
0x00450000 => NetworkProviderType::WNNC_NET_DOCUSHARE,
0xFFFF0000 => NetworkProviderType::WNNC_CRED_MANAGER,
_ => NetworkProviderType::UNKNOWN,
}
}
}
/// The CommonNetworkRelativeLink structure specifies information about the network location where a
/// link target is stored, including the mapped drive letter and the UNC path prefix.
#[derive(Debug, Serialize)]
pub struct CommonNetworkRelativeLink {
#[serde(skip_serializing)]
pub size: u32,
pub flags: Vec<CommonNetworkRelativeLinkFlags>,
#[serde(skip_serializing)]
pub net_name_offset: u32,
#[serde(skip_serializing)]
pub device_name_offset: u32,
pub network_provider_type: Option<NetworkProviderType>,
#[serde(skip_serializing)]
pub net_name_offset_unicode: Option<u32>,
#[serde(skip_serializing)]
pub device_name_offset_unicode: Option<u32>,
#[serde(skip_serializing_if = "Option::is_none")]
pub net_name: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub device_name: Option<String>
}
impl CommonNetworkRelativeLink {
pub fn from_buffer(buf: &[u8]) -> Result<Self> {
Self::from_reader(&mut Cursor::new(buf))
}
pub fn from_reader<R: Read + Seek>(r: &mut R) -> Result<Self> {
let size = r.read_u32::<LittleEndian>()?;
let mut common_network_relative_link_data = vec![0;(size - 4) as usize];
r.read_exact(&mut common_network_relative_link_data)?;
let r = & mut Cursor::new(common_network_relative_link_data);
let mut flags: Vec<CommonNetworkRelativeLinkFlags> = vec![];
match r.read_u32::<LittleEndian>()? {
num if num & 1 > 0 => flags.push(CommonNetworkRelativeLinkFlags::ValidDevice),
num if num & 2 > 0 => flags.push(CommonNetworkRelativeLinkFlags::ValidNetType),
_ => {}
};
let net_name_offset = r.read_u32::<LittleEndian>()?;
let device_name_offset = r.read_u32::<LittleEndian>()?;
let mut network_provider_type = None;
let mut net_name_offset_unicode = None;
let mut device_name_offset_unicode = None;
let net_name;
let mut device_name = None;
if flags.iter().any(|f| match f {
CommonNetworkRelativeLinkFlags::ValidNetType => true,
_ => false,
}) {
network_provider_type = Some(NetworkProviderType::from(
r.read_u32::<LittleEndian>()?
));
}
if net_name_offset > 0x14 {
net_name_offset_unicode = Some(r.read_u32::<LittleEndian>()?);
}
if device_name_offset > 0x14 {
device_name_offset_unicode = Some(r.read_u32::<LittleEndian>()?);
}
net_name = match net_name_offset_unicode {
Some(offset) => match offset {
0 => None,
_ => {
r.seek(SeekFrom::Start((offset-4) as u64))?;
match utils::read_utf16_string(r, None) {
Ok(s) => match s {
s if !s.is_empty() => Some(s),
_ => None
},
Err(_) => None,
}
}
},
None => match net_name_offset {
0 => None,
_ => {
r.seek(SeekFrom::Start((net_name_offset-4) as u64))?;
match utils::read_utf8_string(r, None) {
Ok(s) => match s {
s if !s.is_empty() => Some(s),
_ => None
},
Err(_) => None,
}
}
}
};
// if ValidDevice flag is set then read the device name.
if flags.iter().any(|f| match f {
CommonNetworkRelativeLinkFlags::ValidDevice => true,
_ => false,
}) {
device_name = match device_name_offset_unicode {
Some(offset) => match offset {
0 => None,
_ => {
r.seek(SeekFrom::Start((offset-4) as u64))?;
match utils::read_utf16_string(r, None) {
Ok(s) => match s {
s if !s.is_empty() => Some(s),
_ => None
},
Err(_) => None,
}
}
},
None => match device_name_offset {
0 => None,
_ => {
r.seek(SeekFrom::Start((device_name_offset-4) as u64))?;
match utils::read_utf8_string(r, None) {
Ok(s) => match s {
s if !s.is_empty() => Some(s),
_ => None
},
Err(_) => None,
}
}
}
};
}
Ok(Self {
size,
flags,
net_name_offset,
device_name_offset,
network_provider_type,
net_name_offset_unicode,
device_name_offset_unicode,
net_name,
device_name
})
}
}
impl Path for CommonNetworkRelativeLink {
fn path(&self) -> Option<String> {
match &self.net_name {
Some(net_name) => match &self.device_name {
Some(device_name) => Some(format!("{}\\{}", net_name, device_name)),
None => Some(net_name.to_owned())
},
None => None
}
}
}
|
pub mod core;
pub mod mock;
|
use super::*;
pub fn expression() -> Expression {
Expression {
boostrap_compiler,
typecheck,
codegen,
}
}
fn boostrap_compiler(_compiler: &mut Compiler) {}
fn typecheck(
_resolver: &mut TypeResolver<TypecheckType>,
_: &TypevarFunction,
args: &Vec<TypeVar>,
) -> GenericResult<TypeVar> {
// TODO: figure out how to recurse into nested
// data structure type variables.
Ok(args[0].clone())
}
pub fn codegen(context: &mut Context, args: &[Token]) -> CodegenResult<Object> {
if args.len() != 2 {
return Err(CodegenError::new(&format!(
"match expression should have two arguments: a value to match, and a map to match against. found {:?}",
args
)));
};
let condition = gen_token(context, &args[0])?;
let post_switch_block = context.create_block("postswitch".to_owned());
if let Token::Map(ref map) = &args[1] {
let mut key_values = vec![];
// we construct all keys first, to ensure
// that they exist before the match statement is
// executed.
// TODO: reject keys that are not constants
for key in map.keys() {
let key_value = gen_token(context, &key.as_token())?;
key_values.push(key_value);
}
let num_cases = (map.len() - 1) as u32;
let switch = context.allocate_without_type();
context.add_instruction(LLVMInstruction::BuildSwitch {
value: condition.index,
post_switch_block,
num_cases,
target: switch,
});
for (index, (_key, value)) in map.iter().enumerate() {
let block = context.create_block("case".to_owned());
let branch_key = &key_values[index];
context.add_instruction(LLVMInstruction::AddCase {
switch,
value: branch_key.index,
block: block,
});
let mut branch_context = Context::new(
context.function_map,
context.compiler,
context.function,
context.scope,
block,
);
// context.add_instruction(LLVMInstruction::PositionBuilderAtEnd { block });
// TODO: capture this value and make it the return value of the
// match statement.
gen_token(&mut branch_context, value)?;
if !branch_context.current_block().has_been_terminated() {
branch_context.add_instruction(LLVMInstruction::BuildBr {
block: post_switch_block,
});
}
}
} else {
return Err(CodegenError::new(&format!(
"match expression should be map. found {}",
&args[1]
)));
}
context.block = post_switch_block;
Ok(Object::none())
}
|
fn main() {
let limit = 1000;
let multiples = vec![3, 5];
println!("Sum of all multiples of {:?} up to {} is: {}",
multiples,
limit,
sum_of_multiples(&multiples, &limit));
}
fn sum_of_multiples(multiples: &Vec<i32>, limit: &i32) -> i32 {
let mut result:i32 = 0;
for x in 0..*limit {
for dividor in multiples {
if x % dividor == 0 {
result += x;
break;
}
}
}
result
}
|
use std::env;
use std::fs;
use std::io::Write;
use std::process;
use std::process::Command;
use std::str;
use termcolor::{Color, ColorChoice, ColorSpec, StandardStream, WriteColor};
#[derive(PartialEq, Eq)]
enum ComparisonType {
ShouldContain,
ShouldNotContain,
ShouldEqual,
}
struct UserInput {
file_name: String,
comparison: ComparisonType,
command_being_tested: String,
}
fn parse_args(args: Vec<String>) -> Option<UserInput> {
if args.len() == 5 && args[2] == "to" && args[3] == "output" {
Some(UserInput {
comparison: ComparisonType::ShouldContain,
command_being_tested: args[1].clone(),
file_name: args[4].clone(),
})
} else if args.len() == 6 && args[2] == "to" && args[3] == "not" && args[4] == "output" {
Some(UserInput {
comparison: ComparisonType::ShouldNotContain,
command_being_tested: args[1].clone(),
file_name: args[5].clone(),
})
} else if args.len() == 6 && args[2] == "to" && args[3] == "output" && args[4] == "exactly" {
Some(UserInput {
comparison: ComparisonType::ShouldEqual,
command_being_tested: args[1].clone(),
file_name: args[5].clone(),
})
} else {
None
}
}
fn run_command(cmd: &str) -> String {
let outout = if cfg!(target_os = "windows") {
Command::new("cmd")
.args(&["/C", cmd])
.output()
.expect("failed to execute process")
} else {
Command::new("sh")
.arg("-c")
.arg(cmd)
.output()
.expect("failed to execute process")
}
.stdout;
String::from_utf8(outout).unwrap()
}
fn write_color(text: &str, color: Color) {
let mut stdout = StandardStream::stdout(ColorChoice::Auto);
let _ = stdout.set_color(ColorSpec::new().set_fg(Some(color)));
let _ = writeln!(&mut stdout, "{}", text);
let _ = stdout.reset();
}
fn main() {
const EXIT_CODE_PASSED_TEST: i32 = 0;
const EXIT_CODE_BAD_INPUT: i32 = 1;
const EXIT_CODE_FAILED_TEST: i32 = 2;
let args: Vec<String> = env::args().collect();
let arg_result = parse_args(args);
if arg_result.is_none() {
println!("Usage:");
println!("expect \"command\" to output sample.txt");
println!("expect \"command\" to not output sample.txt");
println!("expect \"command\" to output exactly sample.txt");
process::exit(EXIT_CODE_BAD_INPUT);
}
let user_input = arg_result.unwrap();
let file_read = fs::read_to_string(&user_input.file_name);
if !file_read.is_ok() {
println!("Can't read from {}", &user_input.file_name);
process::exit(EXIT_CODE_BAD_INPUT);
}
let file_content = file_read.unwrap().replace("\r\n", "\n");
let output_to_test = run_command(&user_input.command_being_tested).replace("\r\n", "\n");
let this_comparison = user_input.comparison;
if (this_comparison == ComparisonType::ShouldContain && output_to_test.contains(&file_content))
|| (this_comparison == ComparisonType::ShouldEqual && output_to_test == file_content)
{
write_color("Passed", Color::Green);
println!("Output matched the expectation.");
process::exit(EXIT_CODE_PASSED_TEST);
} else {
write_color("Failed", Color::Red);
println!("Output did not match the expectation.");
process::exit(EXIT_CODE_FAILED_TEST);
}
}
|
use rocket::response::Redirect;
use rocket::State;
use rocket::request::Form;
use rocket_contrib::templates::Template;
use std::collections::HashMap;
use crate::Context;
use crate::model::user::UserDAO;
use crate::routes::helpers::{ get_session, get_user };
use crate::SID;
use crate::TemplateContext;
//
// Show the create user, if needed
//
#[get("/new")]
pub fn new(ctx: State<Context>, sid: SID) -> Result<Template, Redirect> {
// if a user already exists, we're good
match get_user(&ctx, &sid) {
Ok(_) => return Err(Redirect::found("/")),
Err(_) => ()
};
// render the create template
Ok(Template::render("user_create", TemplateContext {
title: "Create User",
parent: "default",
data: HashMap::new(),
user: None,
}))
}
//
// Create user form
//
#[derive(Debug, FromForm)]
pub struct CreateForm {
username: String
}
// TODO: this needs better logging!
// TODO: need to limit usernames to ascii urlsafe character set
#[post("/new", data="<params>")]
pub fn create(ctx: State<Context>, sid: SID, params: Form<CreateForm>) -> Redirect {
let session = match get_session(&ctx, &sid) {
Ok(session) => session,
Err(_) => return Redirect::found("/login")
};
let user_dao = match UserDAO::new(ctx.db.clone()) {
Ok(dao) => dao,
Err(_) => return Redirect::found("/login")
};
match user_dao.create(&session, ¶ms.username) {
Ok(_) => Redirect::found("/user/new"),
Err(_) => Redirect::found("/user/new")
}
}
|
// Copyright 2021, The Tari Project
//
// Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
// following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following
// disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
// following disclaimer in the documentation and/or other materials provided with the distribution.
//
// 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote
// products derived from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
// USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
use crate::{
connectivity::ConnectivitySelection,
peer_manager::{NodeId, Peer},
protocol::{
rpc::{
context::{RequestContext, RpcCommsBackend, RpcCommsProvider},
server::{handle::RpcServerRequest, PeerRpcServer, RpcServerError},
Body,
Request,
Response,
RpcError,
RpcServer,
RpcStatus,
Streaming,
},
ProtocolEvent,
ProtocolId,
ProtocolNotification,
ProtocolNotificationTx,
},
test_utils::mocks::{create_connectivity_mock, create_peer_connection_mock_pair, ConnectivityManagerMockState},
NodeIdentity,
PeerConnection,
PeerManager,
Substream,
};
use async_trait::async_trait;
use bytes::Bytes;
use futures::{channel::mpsc, stream, SinkExt};
use std::sync::Arc;
use tokio::{sync::RwLock, task};
use tower::Service;
use tower_make::MakeService;
pub struct RpcRequestMock {
comms_provider: RpcCommsBackend,
connectivity_mock_state: ConnectivityManagerMockState,
}
impl RpcRequestMock {
pub fn new(peer_manager: Arc<PeerManager>) -> Self {
let (connectivity, connectivity_mock) = create_connectivity_mock();
let connectivity_mock_state = connectivity_mock.get_shared_state();
connectivity_mock.spawn();
Self {
comms_provider: RpcCommsBackend::new(peer_manager, connectivity),
connectivity_mock_state,
}
}
pub fn request_with_context<T>(&self, node_id: NodeId, msg: T) -> Request<T> {
let context = RequestContext::new(node_id, Box::new(self.comms_provider.clone()));
Request::with_context(context, 0.into(), msg)
}
pub fn request_no_context<T>(&self, msg: T) -> Request<T> {
Request::new(0.into(), msg)
}
}
/// # RpcMock trait
///
/// Some common utilities used to mock out an Rpc service.
///
/// Currently, there is a fair amount of manual boilerplate involved. The intention is to discover what the
/// requirements/edge cases are for mocking out RPC services and create a proc macro to generate the
/// boilerplate.
///
/// ## Usage
///
///
/// ```edition2018
/// # use tari_comms::protocol::rpc::mock::{RpcMock, RpcMockMethodState};
/// struct MyServiceMock {
/// // Each method has a field where it's call state (requests, number of calls etc) and canned response are stored
/// my_method: RpcMockMethodState<(), ()>,
/// }
/// // impl MyServiceTrait for MySericeMock {
/// // async fn my_method(&self, request: Request<()>) -> Result<Response<()>, RpcStatus> {
/// // self.request_response(request, &self.my_method).await
/// // }
/// impl RpcMock for MyServiceMock{};
/// ```
#[async_trait]
pub trait RpcMock {
async fn request_response<TReq, TResp>(
&self,
request: Request<TReq>,
method_state: &RpcMockMethodState<TReq, TResp>,
) -> Result<Response<TResp>, RpcStatus>
where
TReq: Send + Sync,
TResp: Send + Sync + Clone,
{
method_state.requests.write().await.push(request.into_message());
let resp = method_state.response.read().await.clone()?;
Ok(Response::new(resp))
}
async fn server_streaming<TReq, TResp>(
&self,
request: Request<TReq>,
method_state: &RpcMockMethodState<TReq, Vec<TResp>>,
) -> Result<Streaming<TResp>, RpcStatus>
where
TReq: Send + Sync,
TResp: Send + Sync + Clone,
{
method_state.requests.write().await.push(request.into_message());
let resp = method_state.response.read().await.clone()?;
let (mut tx, rx) = mpsc::channel(resp.len());
let mut resp = stream::iter(resp.into_iter().map(Ok).map(Ok));
tx.send_all(&mut resp).await.unwrap();
Ok(Streaming::new(rx))
}
}
#[derive(Debug, Clone)]
pub struct RpcMockMethodState<TReq, TResp> {
requests: Arc<RwLock<Vec<TReq>>>,
response: Arc<RwLock<Result<TResp, RpcStatus>>>,
}
impl<TReq, TResp> RpcMockMethodState<TReq, TResp> {
pub async fn request_count(&self) -> usize {
self.requests.read().await.len()
}
pub async fn set_response(&self, response: Result<TResp, RpcStatus>) {
*self.response.write().await = response;
}
}
impl<TReq, TResp: Default> Default for RpcMockMethodState<TReq, TResp> {
fn default() -> Self {
Self {
requests: Default::default(),
response: Arc::new(RwLock::new(Ok(Default::default()))),
}
}
}
#[derive(Debug, Clone)]
pub struct MockCommsProvider;
#[async_trait]
impl RpcCommsProvider for MockCommsProvider {
async fn fetch_peer(&self, _: &NodeId) -> Result<Peer, RpcError> {
unimplemented!()
}
async fn dial_peer(&mut self, _: &NodeId) -> Result<PeerConnection, RpcError> {
unimplemented!()
}
async fn select_connections(&mut self, _: ConnectivitySelection) -> Result<Vec<PeerConnection>, RpcError> {
unimplemented!()
}
}
pub struct MockRpcServer<TSvc, TSubstream> {
inner: Option<PeerRpcServer<TSvc, TSubstream, MockCommsProvider>>,
protocol_tx: ProtocolNotificationTx<TSubstream>,
our_node: Arc<NodeIdentity>,
request_tx: mpsc::Sender<RpcServerRequest>,
}
impl<TSvc> MockRpcServer<TSvc, Substream>
where
TSvc: MakeService<
ProtocolId,
Request<Bytes>,
MakeError = RpcServerError,
Response = Response<Body>,
Error = RpcStatus,
> + Send
+ Sync
+ 'static,
TSvc::Service: Send + 'static,
<TSvc::Service as Service<Request<Bytes>>>::Future: Send + 'static,
TSvc::Future: Send + 'static,
{
pub fn new(service: TSvc, our_node: Arc<NodeIdentity>) -> Self {
let (protocol_tx, protocol_rx) = mpsc::channel(1);
let (request_tx, request_rx) = mpsc::channel(1);
Self {
inner: Some(PeerRpcServer::new(
RpcServer::builder(),
service,
protocol_rx,
MockCommsProvider,
request_rx,
)),
our_node,
protocol_tx,
request_tx,
}
}
/// Create a PeerConnection that can open a substream to this mock server.
pub async fn create_connection(&self, peer: Peer, protocol_id: ProtocolId) -> PeerConnection {
let peer_node_id = peer.node_id.clone();
let (_, our_conn_mock, peer_conn, _) = create_peer_connection_mock_pair(1, peer, self.our_node.to_peer()).await;
let mut protocol_tx = self.protocol_tx.clone();
task::spawn(async move {
while let Some(substream) = our_conn_mock.next_incoming_substream().await {
let proto_notif = ProtocolNotification::new(
protocol_id.clone(),
ProtocolEvent::NewInboundSubstream(peer_node_id.clone(), substream),
);
protocol_tx.send(proto_notif).await.unwrap();
}
});
peer_conn
}
pub fn serve(&mut self) -> task::JoinHandle<Result<(), RpcServerError>> {
let inner = self.inner.take().expect("can only call `serve` once");
task::spawn(inner.serve())
}
}
|
use crate::comp::{
Agent, CharacterState, Controller, MountState, MovementState::Glide, Pos, Stats,
};
use rand::{seq::SliceRandom, thread_rng};
use specs::{Entities, Join, ReadStorage, System, WriteStorage};
use vek::*;
/// This system will allow NPCs to modify their controller
pub struct Sys;
impl<'a> System<'a> for Sys {
type SystemData = (
Entities<'a>,
ReadStorage<'a, Pos>,
ReadStorage<'a, Stats>,
ReadStorage<'a, CharacterState>,
WriteStorage<'a, Agent>,
WriteStorage<'a, Controller>,
ReadStorage<'a, MountState>,
);
fn run(
&mut self,
(entities, positions, stats, character_states, mut agents, mut controllers, mount_states): Self::SystemData,
) {
for (entity, pos, agent, controller, mount_state) in (
&entities,
&positions,
&mut agents,
&mut controllers,
mount_states.maybe(),
)
.join()
{
// Skip mounted entities
if mount_state
.map(|ms| {
if let MountState::Unmounted = ms {
false
} else {
true
}
})
.unwrap_or(false)
{
continue;
}
controller.reset();
match agent {
Agent::Wanderer(bearing) => {
*bearing += Vec2::new(rand::random::<f32>() - 0.5, rand::random::<f32>() - 0.5)
* 0.1
- *bearing * 0.01
- pos.0 * 0.0002;
if bearing.magnitude_squared() > 0.001 {
controller.move_dir = bearing.normalized();
}
}
Agent::Pet { target, offset } => {
// Run towards target.
match positions.get(*target) {
Some(tgt_pos) => {
let tgt_pos = tgt_pos.0 + *offset;
if tgt_pos.z > pos.0.z + 1.0 {
controller.jump = true;
}
// Move towards the target.
let dist: f32 = Vec2::from(tgt_pos - pos.0).magnitude();
controller.move_dir = if dist > 5.0 {
Vec2::from(tgt_pos - pos.0).normalized()
} else if dist < 1.5 && dist > 0.001 {
Vec2::from(pos.0 - tgt_pos).normalized()
} else {
Vec2::zero()
};
}
_ => controller.move_dir = Vec2::zero(),
}
// Change offset occasionally.
if rand::random::<f32>() < 0.003 {
*offset =
Vec2::new(rand::random::<f32>() - 0.5, rand::random::<f32>() - 0.5)
* 10.0;
}
}
Agent::Enemy { bearing, target } => {
const SIGHT_DIST: f32 = 30.0;
const MIN_ATTACK_DIST: f32 = 3.5;
let mut choose_new = false;
if let Some((Some(target_pos), Some(target_stats), Some(target_character))) =
target.map(|target| {
(
positions.get(target),
stats.get(target),
character_states.get(target),
)
})
{
controller.look_dir = target_pos.0 - pos.0;
let dist = Vec2::<f32>::from(target_pos.0 - pos.0).magnitude();
if target_stats.is_dead {
choose_new = true;
} else if dist < MIN_ATTACK_DIST && dist > 0.001 {
// Fight (and slowly move closer)
controller.move_dir =
Vec2::<f32>::from(target_pos.0 - pos.0).normalized() * 0.01;
controller.primary = true;
} else if dist < SIGHT_DIST {
controller.move_dir =
Vec2::<f32>::from(target_pos.0 - pos.0).normalized() * 0.96;
if rand::random::<f32>() < 0.02 {
controller.roll = true;
}
if target_character.movement == Glide && target_pos.0.z > pos.0.z + 5.0
{
controller.glide = true;
controller.jump = true;
}
} else {
choose_new = true;
}
} else {
*bearing +=
Vec2::new(rand::random::<f32>() - 0.5, rand::random::<f32>() - 0.5)
* 0.1
- *bearing * 0.005;
controller.move_dir = if bearing.magnitude_squared() > 0.001 {
bearing.normalized()
} else {
Vec2::zero()
};
choose_new = true;
}
if choose_new && rand::random::<f32>() < 0.1 {
let entities = (&entities, &positions, &stats)
.join()
.filter(|(e, e_pos, e_stats)| {
(e_pos.0 - pos.0).magnitude() < SIGHT_DIST
&& *e != entity
&& !e_stats.is_dead
})
.map(|(e, _, _)| e)
.collect::<Vec<_>>();
let mut rng = thread_rng();
*target = (&entities).choose(&mut rng).cloned();
}
}
}
}
}
}
|
use redis::{AsyncCommands, FromRedisValue, RedisError, ToRedisArgs};
use serenity::client::Context;
use crate::data::RedisConnection;
pub async fn set<'a, K, V>(ctx: &Context, key: K, value: V) -> Result<(), RedisError>
where
K: ToRedisArgs + Send + Sync + 'a,
V: ToRedisArgs + Send + Sync + 'a,
{
let data = ctx.data.as_ref().read().await;
let con = data.get::<RedisConnection>().unwrap().clone();
let con = con.lock().await;
let mut con = con.get_async_connection().await?;
let _: String = con.set(key, value).await?;
Ok(())
}
pub async fn get<'a, K, RV>(ctx: &Context, key: K) -> Result<RV, RedisError>
where
K: ToRedisArgs + Send + Sync + 'a,
RV: FromRedisValue,
{
let data = ctx.data.as_ref().read().await;
let con = data.get::<RedisConnection>().unwrap().clone();
let con = con.lock().await;
let mut con = con.get_async_connection().await?;
let rv = con.get(key).await?;
Ok(rv)
}
pub async fn del<'a, K>(ctx: &Context, key: K) -> Result<(), RedisError>
where
K: ToRedisArgs + Send + Sync + 'a,
{
let data = ctx.data.as_ref().read().await;
let con = data.get::<RedisConnection>().unwrap().clone();
let con = con.lock().await;
let mut con = con.get_async_connection().await?;
con.del(key).await?;
Ok(())
}
|
/**
* Authors: Jorge Martins && Diogo Lopes
* This example is from Vasconcelos, V.T. (and several others):
* "Behavioral Types in Programming Languages" (figures 2.4, 2.5 and 2.6)
*/
use crate::customer::*;
use std::thread;
extern crate chan;
mod agency;
mod customer;
mod message;
mod service;
fn main() {
//some mock values
let max_price: f64 = 1000.00;
let country = String::from("Portugal");
let city = String::from("Lisbon");
let street = String::from("Rua Augusta");
let addr: Address = Address::new(country, city, street);
let journey_pref: String = String::from("Rome");
//channel that will be used in the communication
let (send, recv) = chan::sync::<message::Message>(0);
//start the customer
let customer = thread::spawn(move || {
customer::order(send, recv, max_price, addr, journey_pref);
});
let _ = customer.join();
}
|
// Copyright 2020 IOTA Stiftung
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
// the License. You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
// an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and limitations under the License.
//! `bee-tangle`
#![deny(missing_docs)]
#![allow(dead_code, unused_imports, unused_variables)]
pub use milestone::MilestoneIndex;
pub use tangle::Tangle;
pub use vertex::TransactionRef;
mod milestone;
mod solidifier;
mod tangle;
mod vertex;
use solidifier::SolidifierState;
use async_std::{
sync::{channel, Arc, Barrier},
task::spawn,
};
use bee_bundle::Hash;
use std::{
ptr,
sync::atomic::{AtomicBool, AtomicPtr, Ordering},
};
static TANGLE: AtomicPtr<Tangle> = AtomicPtr::new(ptr::null_mut());
static INITIALIZED: AtomicBool = AtomicBool::new(false);
const SOLIDIFIER_CHAN_CAPACITY: usize = 1000;
/// Initializes the Tangle singleton.
pub fn init() {
if !INITIALIZED.compare_and_swap(false, true, Ordering::Relaxed) {
let (sender, receiver) = flume::bounded::<Option<Hash>>(SOLIDIFIER_CHAN_CAPACITY);
let drop_barrier = async_std::sync::Arc::new(Barrier::new(2));
TANGLE.store(
Box::into_raw(Tangle::new(sender, drop_barrier.clone()).into()),
Ordering::Relaxed,
);
spawn(SolidifierState::new(receiver, drop_barrier).run());
} else {
drop();
panic!("Already initialized");
}
}
/// Returns the singleton instance of the Tangle.
pub fn tangle() -> &'static Tangle {
let tangle = TANGLE.load(Ordering::Relaxed);
if tangle.is_null() {
panic!("Tangle cannot be null");
} else {
unsafe { &*tangle }
}
}
/// Drops the Tangle singleton.
pub fn drop() {
if INITIALIZED.compare_and_swap(true, false, Ordering::Relaxed) {
tangle().shutdown();
let tangle = TANGLE.swap(ptr::null_mut(), Ordering::Relaxed);
if !tangle.is_null() {
let _ = unsafe { Box::from_raw(tangle) };
}
} else {
panic!("Already dropped");
}
}
#[cfg(test)]
mod tests {
use super::*;
use serial_test::serial;
#[test]
#[serial]
fn init_get_and_drop() {
init();
let _ = tangle();
drop();
}
#[test]
#[should_panic]
#[serial]
fn double_init_should_panic() {
init();
init();
}
#[test]
#[should_panic]
#[serial]
fn double_drop_should_panic() {
init();
drop();
drop();
}
#[test]
#[should_panic]
#[serial]
fn drop_without_init_should_panic() {
drop();
}
#[test]
#[should_panic]
#[serial]
fn get_without_init_should_panic() {
let _ = tangle();
drop();
}
}
|
use num::BigInt;
use crate::special::get_fermat_primes;
pub fn is_fermat_prime<T>(i: T) -> bool
where
BigInt: From<T>,
{
//
let int = BigInt::from(i);
let list = get_fermat_primes();
list.contains(&int)
}
|
#[macro_use]
extern crate rusx;
fn main() {
use rusx::prelude::*;
#[derive(Debug)]
struct Styled<'a> {
bt: BlockType,
body: &'a str,
font_family: &'a str,
font_size: f32,
font_weight: f32,
color: &'a str,
italic: bool,
underline: bool,
margin: Spacing,
padding: Spacing,
}
#[derive(Debug, Default)]
struct Spacing(f32, f32, f32, f32);
#[derive(Debug)]
enum BlockType {
Header1,
Header2,
Header3,
Header4,
Header5,
Header6,
Body,
Quote,
Code,
Numbered,
Bullet,
ListItem,
}
use BlockType::*;
impl Default for Styled<'_> {
fn default() -> Self {
Self {
bt: Body,
body: "",
font_family: "serif",
font_size: 12.0,
font_weight: 400.0,
color: "black",
italic: false,
underline: false,
margin: Spacing::default(),
padding: Spacing::default(),
}
}
}
let styles = rusx! {
<Styled> {
<bt=Header1, body="This is my header!", color="pink">,
<body="This is a body section of text", italic=true> {
<bt=Quote, body="This is a quote inside the body.">
},
<body="This is another body section of text.">,
<bt=Header2, body="About Me", color="blue">,
<body="Here are some things about me:", margin={Spacing(10.0, 0.0, 0.0, 0.0)}>,
<bt=Numbered> {
<bt=ListItem, body="I am the first list item.">,
<bt=ListItem, body="I am the second list item.">,
<bt=ListItem, body="I am the third list item.">
}
}
};
println!("{:#?}", styles);
}
|
use plotters::prelude::*;
use adafruit_gps::GpsSentence;
use crate::kinematics::{inverse_vincenty};
/// # Position Accuracy
/// Given a set of coordinates, produce the average longitude and latitude,
use super::Coordinate;
use std::fs::File;
use std::io::Write;
pub trait GpsSentenceConverter {
fn to_coords(&self, include_geoidal_separation: bool) -> Vec<Coordinate>;
}
impl GpsSentenceConverter for Vec<GpsSentence> {
/// Converts Vec<GpsSentence> to Vec<Coordinate>. Ignores GpsSentence types that have no long
/// lat data in it. Adds all data it has.
///
/// include_geoidal_separation argument allows for altitude to equal mean sea level alt + geoidal
/// separation for height above the ground. If there is no geoidal separation data available
/// then nothing is added.
fn to_coords(&self, include_geoidal_separation: bool) -> Vec<Coordinate> {
let mut vec_coord = Vec::new();
for s in self.iter() {
match s {
GpsSentence::GGA(sentence) => {
let mut gga = Coordinate {
utc: sentence.utc,
latitude: sentence.lat,
longitude: sentence.long,
altitude: sentence.msl_alt,
};
if include_geoidal_separation && gga.altitude.is_some() && sentence.geoidal_sep.is_some(){
gga.altitude = Some(gga.altitude.unwrap() + sentence.geoidal_sep.unwrap());
}
vec_coord.push(gga);
}
GpsSentence::GLL(sentence) => {
vec_coord.push(Coordinate {
utc: sentence.utc.unwrap_or(0.0),
latitude: sentence.latitude,
longitude: sentence.longitude,
altitude: None,
});
}
GpsSentence::RMC(sentence) => {
vec_coord.push(Coordinate {
utc: sentence.utc,
latitude: sentence.latitude,
longitude: sentence.longitude,
altitude: None,
});
}
_ => {}
};
}
vec_coord
}
}
pub trait Position {
fn average_long_lat(&self) -> Coordinate;
fn plot_positions(&self, name: &str);
fn to_klm(&self, name: &str, description: &str) -> std::io::Result<()>;
}
impl Position for Vec<Coordinate> {
/// # Latitude and Longitude variation
/// https://stackoverflow.com/questions/6671183/calculate-the-center-point-of-multiple-latitude-longitude-coordinate-pairs
/// # Altitude variation
/// Simple mean of the altitudes.
///
/// Returns a Location structure with each long, lat and altitude being the average. UTC is 0.
///
/// Assume that all points in the Vec<Location> are valid.
fn average_long_lat(&self) -> Coordinate {
let mut x: f64 = 0.0;
let mut y: f64 = 0.0;
let mut z: f64 = 0.0;
let mut altitude: f64 = 0.0;
for location in self.iter() {
x += (location.latitude.unwrap().cos() * location.longitude.unwrap().cos()) as f64;
y += (location.latitude.unwrap().cos() * location.longitude.unwrap().sin()) as f64;
z += location.latitude.unwrap().sin() as f64;
altitude += location.altitude.unwrap() as f64;
}
x = x / self.len() as f64;
y = y / self.len() as f64;
z = z / self.len() as f64;
let central_long = y.atan2(x);
let central_sq_rt = (x * x + y * y).sqrt();
let central_lat = z.atan2(central_sq_rt);
let average_long = central_long.to_degrees();
let average_lat = central_lat.to_degrees();
let average_alt: f64 = altitude / self.len() as f64;
return Coordinate {
latitude: Some(average_lat as f32),
longitude: Some(average_long as f32),
altitude: Some(average_alt as f32),
utc: 0.0,
};
}
/// Plots the longitude and latitiude coordinates on a 2d graph using plotters.
fn plot_positions(&self, name: &str) {
let mut positions: Vec<(f32, f32)> = self.into_iter()
.map(|x| (x.longitude.unwrap(), x.latitude.unwrap())).collect();
positions.retain(|x| *x != (0.0, 0.0)); // Remove all (0,0) coords.
let latitudes: Vec<f32> = positions.clone().into_iter().map(|x| x.0).collect();
let longitudes: Vec<f32> = positions.clone().into_iter().map(|x| x.1).collect();
let min_long = longitudes.iter().cloned().fold(0. / 0., f32::min);
let max_long = longitudes.iter().cloned().fold(0. / 0., f32::max);
let min_lat = latitudes.iter().cloned().fold(0. / 0., f32::min);
let max_lat = latitudes.iter().cloned().fold(0. / 0., f32::max);
// // x axis is
// let _x_axis = inverse_vincenty(
// &Coordinate { utc: 0.0, latitude: Some(min_lat), longitude: Some(min_long), altitude: Some(0.0) },
// &Coordinate { utc: 0.0, latitude: Some(min_lat), longitude: Some(max_long), altitude: Some(0.0) });
// let _y_axis = inverse_vincenty(
// &Coordinate { utc: 0.0, latitude: Some(min_lat), longitude: Some(min_long), altitude: Some(0.0) },
// &Coordinate { utc: 0.0, latitude: Some(max_lat), longitude: Some(max_long), altitude: Some(0.0) },
// );
let file_name = format!("images/{}.png", name);
let root_area = BitMapBackend::new(file_name.as_str(), (600, 600))
.into_drawing_area();
root_area.fill(&WHITE).unwrap();
let mut ctx = ChartBuilder::on(&root_area)
.set_label_area_size(LabelAreaPosition::Left, 40)
.set_label_area_size(LabelAreaPosition::Bottom, 40)
.caption(name, ("Arial", 40))
.build_ranged(min_lat..max_lat, min_long..max_long)
.unwrap();
ctx.configure_mesh().draw().unwrap();
ctx.draw_series(
LineSeries::new(
positions, &BLUE))
.unwrap();
}
fn to_klm(&self, name: &str, description: &str) -> std::io::Result<()>{
let mut coordinates = String::new();
for c in self.iter() {
if c.latitude.is_some() && c.longitude.is_some() && c.altitude.is_some() {
coordinates.push_str(format!(
"{},{},{}
", c.longitude.unwrap(), c.latitude.unwrap(), c.altitude.unwrap()).as_str());
}
}
let mut klm_string = String::new();
klm_string.push_str(
format!(
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>
<kml xmlns=\"http://www.opengis.net/kml/2.2\">
<Document>
<name>{}</name>
<description>{}</description>
<Style id=\"yellowLineGreenPoly\">
<LineStyle>
<color>7f00ffff</color>
<width>4</width>
</LineStyle>
<PolyStyle>
<color>7f00ff00</color>
</PolyStyle>
</Style>
<Placemark>
<name>Coordinate path</name>
<description>Transparent green wall with yellow outlines</description>
<styleUrl>#yellowLineGreenPoly</styleUrl>
<LineString>
<extrude>1</extrude>
<tessellate>1</tessellate>
<altitudeMode>absolute</altitudeMode>
<coordinates> {} </coordinates>
</LineString>
</Placemark>
</Document>
</kml>
", name, description, coordinates).as_str());
let mut file = File::create(format!("{}.kml", name))?;
file.write_all(klm_string.as_bytes())?;
Ok(())
}
}
|
use std::collections::HashMap;
use super::field_table::{FieldTableEntry, FieldTableType};
pub struct FileCreatorTable {
table: FieldTableType
}
impl FieldTableEntry for FileCreatorTable {
fn get(&self, key: i32) -> String {
let result = self.table.get(&key);
match result {
Some(r) => r.clone(),
None => panic!("Unrecognized File Creator Key: {}", key)
}
}
}
impl FileCreatorTable {
pub fn new() -> FileCreatorTable {
FileCreatorTable {
table: FileCreatorTable::make_table()
}
}
fn make_table() -> FieldTableType {
let mut file_creator_table = FieldTableType::new();
file_creator_table.insert(0, String::from("software_version"));
file_creator_table.insert(1, String::from("hardware_version"));
file_creator_table
}
}
|
use std::{fmt::Display, ops::Range};
use annotate_snippets::{
display_list::{DisplayList, FormatOptions},
snippet::{Annotation, AnnotationType, Slice, Snippet, SourceAnnotation},
};
use crate::utils::joined_by::*;
#[derive(Clone, Debug, Eq, PartialEq, Hash)]
pub struct GlobalSpan(pub Range<usize>);
#[derive(Clone, Debug, Eq, PartialEq, Hash)]
pub struct LocalSpan(pub Range<usize>);
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct Spanned<T> {
pub span: GlobalSpan,
pub inner: T,
}
impl GlobalSpan {
pub fn localize_span(self, start: usize) -> LocalSpan { LocalSpan(self.0.start - start..self.0.end - start) }
}
impl LocalSpan {
pub fn globalize_span(self, start: usize) -> GlobalSpan { GlobalSpan(self.0.start + start..self.0.end + start) }
}
impl<T> Spanned<T> {
pub fn new(t: T, span: GlobalSpan) -> Self { Spanned { span, inner: t } }
pub fn map<Y, F: FnOnce(T) -> Y>(self, f: F) -> Spanned<Y> { Spanned { span: self.span, inner: f(self.inner) } }
}
impl<T: Display> Spanned<T> {
pub fn print_error_snippet<'a>(&self, string: &'a str) {
let text = self.inner.to_string();
let (line_no, line_range_start) = find_line_number(string, self.span.0.start);
let (_, line_range_end) = find_line_number(string, self.span.0.end);
let snippet = Snippet {
title: Some(Annotation { label: Some(&text), id: None, annotation_type: AnnotationType::Error }),
footer: vec![],
slices: vec![Slice {
source: &string[line_range_start.start..line_range_end.end],
line_start: line_no,
origin: None,
fold: true,
annotations: vec![SourceAnnotation {
label: "",
annotation_type: AnnotationType::Error,
range: (self.span.0.start - line_range_start.start, self.span.0.end - line_range_start.start),
}],
}],
opt: FormatOptions { color: true, ..Default::default() },
};
println!("{}", DisplayList::from(snippet));
}
}
fn find_char_pos(string: &str, byte_pos: usize) -> usize {
string
.char_indices()
.map(|(index, _)| index)
.enumerate()
.find(|(_, index)| index == &byte_pos)
.map(|(char_pos, _)| char_pos)
.unwrap_or_else(|| panic!("Wrong position `{:?}` on string: {:?}", byte_pos.clone(), string))
}
fn find_line_number(string: &str, pos: usize) -> (usize, Range<usize>) {
string
.char_indices()
.filter(|(_, ch)| *ch == '\n')
.enumerate()
.scan(0, |state, x| {
let result = (x.0, *state + 1..x.1.0);
*state = x.1.0;
Some(result)
})
.find(|(_, range)| range.contains(&pos))
.map(|(line_no, range)| (line_no + 1, range))
.unwrap()
}
pub trait GetErrorCharsRange {
fn get_error_range(&self, string: &str) -> (usize, usize);
}
impl GetErrorCharsRange for usize {
fn get_error_range(&self, string: &str) -> (usize, usize) {
(find_char_pos(string, *self), find_char_pos(string, *self) + 1)
}
}
impl GetErrorCharsRange for peg::str::LineCol {
fn get_error_range(&self, string: &str) -> (usize, usize) {
(find_char_pos(string, self.offset), find_char_pos(string, self.offset) + 1)
}
}
impl GetErrorCharsRange for std::ops::Range<usize> {
fn get_error_range(&self, string: &str) -> (usize, usize) {
(find_char_pos(string, self.start), find_char_pos(string, self.end))
}
}
/// Преобразование ошибки `rust-peg` в формат `snippet`.
pub fn peg_error_to_snippet<T: GetErrorCharsRange>(err: peg::error::ParseError<T>, string: &str) {
let inner_text =
format!("expected tokens: {}", err.expected.tokens().collect::<Vec<_>>().into_iter().joined_by(", "));
let snippet = Snippet {
title: Some(Annotation { label: Some("unexpected token"), id: None, annotation_type: AnnotationType::Error }),
footer: vec![Annotation { label: Some(&inner_text), id: None, annotation_type: AnnotationType::Note }],
slices: vec![Slice {
source: string,
line_start: 0,
origin: None,
fold: true,
annotations: vec![SourceAnnotation {
label: "unexpected token",
annotation_type: AnnotationType::Error,
range: err.location.get_error_range(string),
}],
}],
opt: FormatOptions { color: true, ..Default::default() },
};
println!("{}", DisplayList::from(snippet));
}
|
use crate::services::Error;
use yew::services::fetch::FetchTask;
#[derive(Default, Debug)]
pub struct Request {
task: Option<FetchTask>,
task_error: Option<Error>,
}
impl Request {
pub fn new() -> Self {
Self {
task: None,
task_error: None,
}
}
#[allow(dead_code)]
pub fn error(&self) -> Option<Error> {
self.task_error.clone()
}
pub fn request(&mut self, task: FetchTask) {
self.task = Some(task)
}
pub fn response<T>(&mut self, response: Result<T, Error>) -> Option<T> {
match response {
Ok(meal_plans) => {
self.task_error = None;
self.task = None;
Some(meal_plans)
}
Err(err) => {
self.task_error = Some(err);
self.task = None;
None
}
}
}
}
|
use std::fmt;
#[derive(Clone, Debug)]
/// Errors encountered when sampling coordinates.
pub enum Error<const D: usize> {
/// Invalid input box size to sample coordinates in.
///
/// All box size lengths must be positive, real values.
InvalidBoxSize { value: f64, box_size: Vec<f64> },
/// Invalid input minimum distance between coordinates.
///
/// Minimum distance must be a positive, real value. This will also be yielded
/// for infinite and not-a-number values.
InvalidRmin(f64),
/// Generated a coordinate that was outside the box.
///
/// This should not happen. Please file an issue if you encounter this.
GenCoordOutOfBounds([f64; D]),
/// The active list is inconsistent.
///
/// This should not happen. Please file an issue if you encounter this.
InvalidActiveList,
}
impl<const D: usize> fmt::Display for Error<D> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Error::InvalidBoxSize { value, box_size } => write!(
f,
"invalid value '{}' in input box size '{:?}': must be a positive number",
value, box_size
),
Error::InvalidRmin(rmin) => write!(
f,
"invalid value for input `rmin` ({}): must be a positive number",
rmin
),
Error::GenCoordOutOfBounds(coord) => write!(
f,
"generated and used an out-of-box coordinate ({:?}): this should not happen, please file an issue",
coord
),
Error::InvalidActiveList => write!(
f,
"active list contains an index which does not lead to a sample: this should not happen, please file an issue"
),
}
}
}
impl<const D: usize> std::error::Error for Error<D> {}
#[cfg(test)]
impl<const D: usize> Error<D> {
pub(crate) fn is_invalid_box_size(&self) -> bool {
match self {
Error::InvalidBoxSize { .. } => true,
_ => false,
}
}
pub(crate) fn is_invalid_rmin(&self) -> bool {
match self {
Error::InvalidRmin(_) => true,
_ => false,
}
}
}
|
#[doc = "Register `ODISR` reader"]
pub type R = crate::R<ODISR_SPEC>;
#[doc = "Register `ODISR` writer"]
pub type W = crate::W<ODISR_SPEC>;
#[doc = "Field `TA1ODIS` reader - TA1ODIS"]
pub type TA1ODIS_R = crate::BitReader<TA1ODIS_A>;
#[doc = "TA1ODIS\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum TA1ODIS_A {
#[doc = "1: Disable output"]
Disable = 1,
}
impl From<TA1ODIS_A> for bool {
#[inline(always)]
fn from(variant: TA1ODIS_A) -> Self {
variant as u8 != 0
}
}
impl TA1ODIS_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> Option<TA1ODIS_A> {
match self.bits {
true => Some(TA1ODIS_A::Disable),
_ => None,
}
}
#[doc = "Disable output"]
#[inline(always)]
pub fn is_disable(&self) -> bool {
*self == TA1ODIS_A::Disable
}
}
#[doc = "Field `TA1ODIS` writer - TA1ODIS"]
pub type TA1ODIS_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O, TA1ODIS_A>;
impl<'a, REG, const O: u8> TA1ODIS_W<'a, REG, O>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "Disable output"]
#[inline(always)]
pub fn disable(self) -> &'a mut crate::W<REG> {
self.variant(TA1ODIS_A::Disable)
}
}
#[doc = "Field `TA2ODIS` reader - TA2ODIS"]
pub use TA1ODIS_R as TA2ODIS_R;
#[doc = "Field `TB1ODIS` reader - TB1ODIS"]
pub use TA1ODIS_R as TB1ODIS_R;
#[doc = "Field `TB2ODIS` reader - TB2ODIS"]
pub use TA1ODIS_R as TB2ODIS_R;
#[doc = "Field `TC1ODIS` reader - TC1ODIS"]
pub use TA1ODIS_R as TC1ODIS_R;
#[doc = "Field `TC2ODIS` reader - TC2ODIS"]
pub use TA1ODIS_R as TC2ODIS_R;
#[doc = "Field `TD1ODIS` reader - TD1ODIS"]
pub use TA1ODIS_R as TD1ODIS_R;
#[doc = "Field `TD2ODIS` reader - TD2ODIS"]
pub use TA1ODIS_R as TD2ODIS_R;
#[doc = "Field `TE1ODIS` reader - TE1ODIS"]
pub use TA1ODIS_R as TE1ODIS_R;
#[doc = "Field `TE2ODIS` reader - TE2ODIS"]
pub use TA1ODIS_R as TE2ODIS_R;
#[doc = "Field `TA2ODIS` writer - TA2ODIS"]
pub use TA1ODIS_W as TA2ODIS_W;
#[doc = "Field `TB1ODIS` writer - TB1ODIS"]
pub use TA1ODIS_W as TB1ODIS_W;
#[doc = "Field `TB2ODIS` writer - TB2ODIS"]
pub use TA1ODIS_W as TB2ODIS_W;
#[doc = "Field `TC1ODIS` writer - TC1ODIS"]
pub use TA1ODIS_W as TC1ODIS_W;
#[doc = "Field `TC2ODIS` writer - TC2ODIS"]
pub use TA1ODIS_W as TC2ODIS_W;
#[doc = "Field `TD1ODIS` writer - TD1ODIS"]
pub use TA1ODIS_W as TD1ODIS_W;
#[doc = "Field `TD2ODIS` writer - TD2ODIS"]
pub use TA1ODIS_W as TD2ODIS_W;
#[doc = "Field `TE1ODIS` writer - TE1ODIS"]
pub use TA1ODIS_W as TE1ODIS_W;
#[doc = "Field `TE2ODIS` writer - TE2ODIS"]
pub use TA1ODIS_W as TE2ODIS_W;
impl R {
#[doc = "Bit 0 - TA1ODIS"]
#[inline(always)]
pub fn ta1odis(&self) -> TA1ODIS_R {
TA1ODIS_R::new((self.bits & 1) != 0)
}
#[doc = "Bit 1 - TA2ODIS"]
#[inline(always)]
pub fn ta2odis(&self) -> TA2ODIS_R {
TA2ODIS_R::new(((self.bits >> 1) & 1) != 0)
}
#[doc = "Bit 2 - TB1ODIS"]
#[inline(always)]
pub fn tb1odis(&self) -> TB1ODIS_R {
TB1ODIS_R::new(((self.bits >> 2) & 1) != 0)
}
#[doc = "Bit 3 - TB2ODIS"]
#[inline(always)]
pub fn tb2odis(&self) -> TB2ODIS_R {
TB2ODIS_R::new(((self.bits >> 3) & 1) != 0)
}
#[doc = "Bit 4 - TC1ODIS"]
#[inline(always)]
pub fn tc1odis(&self) -> TC1ODIS_R {
TC1ODIS_R::new(((self.bits >> 4) & 1) != 0)
}
#[doc = "Bit 5 - TC2ODIS"]
#[inline(always)]
pub fn tc2odis(&self) -> TC2ODIS_R {
TC2ODIS_R::new(((self.bits >> 5) & 1) != 0)
}
#[doc = "Bit 6 - TD1ODIS"]
#[inline(always)]
pub fn td1odis(&self) -> TD1ODIS_R {
TD1ODIS_R::new(((self.bits >> 6) & 1) != 0)
}
#[doc = "Bit 7 - TD2ODIS"]
#[inline(always)]
pub fn td2odis(&self) -> TD2ODIS_R {
TD2ODIS_R::new(((self.bits >> 7) & 1) != 0)
}
#[doc = "Bit 8 - TE1ODIS"]
#[inline(always)]
pub fn te1odis(&self) -> TE1ODIS_R {
TE1ODIS_R::new(((self.bits >> 8) & 1) != 0)
}
#[doc = "Bit 9 - TE2ODIS"]
#[inline(always)]
pub fn te2odis(&self) -> TE2ODIS_R {
TE2ODIS_R::new(((self.bits >> 9) & 1) != 0)
}
}
impl W {
#[doc = "Bit 0 - TA1ODIS"]
#[inline(always)]
#[must_use]
pub fn ta1odis(&mut self) -> TA1ODIS_W<ODISR_SPEC, 0> {
TA1ODIS_W::new(self)
}
#[doc = "Bit 1 - TA2ODIS"]
#[inline(always)]
#[must_use]
pub fn ta2odis(&mut self) -> TA2ODIS_W<ODISR_SPEC, 1> {
TA2ODIS_W::new(self)
}
#[doc = "Bit 2 - TB1ODIS"]
#[inline(always)]
#[must_use]
pub fn tb1odis(&mut self) -> TB1ODIS_W<ODISR_SPEC, 2> {
TB1ODIS_W::new(self)
}
#[doc = "Bit 3 - TB2ODIS"]
#[inline(always)]
#[must_use]
pub fn tb2odis(&mut self) -> TB2ODIS_W<ODISR_SPEC, 3> {
TB2ODIS_W::new(self)
}
#[doc = "Bit 4 - TC1ODIS"]
#[inline(always)]
#[must_use]
pub fn tc1odis(&mut self) -> TC1ODIS_W<ODISR_SPEC, 4> {
TC1ODIS_W::new(self)
}
#[doc = "Bit 5 - TC2ODIS"]
#[inline(always)]
#[must_use]
pub fn tc2odis(&mut self) -> TC2ODIS_W<ODISR_SPEC, 5> {
TC2ODIS_W::new(self)
}
#[doc = "Bit 6 - TD1ODIS"]
#[inline(always)]
#[must_use]
pub fn td1odis(&mut self) -> TD1ODIS_W<ODISR_SPEC, 6> {
TD1ODIS_W::new(self)
}
#[doc = "Bit 7 - TD2ODIS"]
#[inline(always)]
#[must_use]
pub fn td2odis(&mut self) -> TD2ODIS_W<ODISR_SPEC, 7> {
TD2ODIS_W::new(self)
}
#[doc = "Bit 8 - TE1ODIS"]
#[inline(always)]
#[must_use]
pub fn te1odis(&mut self) -> TE1ODIS_W<ODISR_SPEC, 8> {
TE1ODIS_W::new(self)
}
#[doc = "Bit 9 - TE2ODIS"]
#[inline(always)]
#[must_use]
pub fn te2odis(&mut self) -> TE2ODIS_W<ODISR_SPEC, 9> {
TE2ODIS_W::new(self)
}
#[doc = "Writes raw bits to the register."]
#[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.bits = bits;
self
}
}
#[doc = "DISR\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`odisr::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`odisr::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct ODISR_SPEC;
impl crate::RegisterSpec for ODISR_SPEC {
type Ux = u32;
}
#[doc = "`read()` method returns [`odisr::R`](R) reader structure"]
impl crate::Readable for ODISR_SPEC {}
#[doc = "`write(|w| ..)` method takes [`odisr::W`](W) writer structure"]
impl crate::Writable for ODISR_SPEC {
const ZERO_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
}
#[doc = "`reset()` method sets ODISR to value 0"]
impl crate::Resettable for ODISR_SPEC {
const RESET_VALUE: Self::Ux = 0;
}
|
use apllodb_sql_parser::{
apllodb_ast::{
Action, AlterTableCommand, ColumnConstraint, ColumnDefinition, Command, DataType,
},
ApllodbAst, ApllodbSqlParser,
};
use apllodb_test_support::setup::setup_test_logger;
#[ctor::ctor]
fn test_setup() {
setup_test_logger();
}
#[test]
fn test_alter_table_accepted() {
let sql_vs_expected_ast: Vec<(&str, AlterTableCommand)> = vec![
(
"ALTER TABLE t ADD COLUMN c1 INTEGER",
AlterTableCommand::factory(
"t",
vec![Action::factory_add_col(ColumnDefinition::factory(
"c1",
DataType::integer(),
vec![],
))],
),
),
(
"ALTER TABLE t ADD c1 INTEGER",
AlterTableCommand::factory(
"t",
vec![Action::factory_add_col(ColumnDefinition::factory(
"c1",
DataType::integer(),
vec![],
))],
),
),
(
"ALTER TABLE t ADD COLUMN c1 INTEGER NOT NULL, DROP COLUMN c2",
AlterTableCommand::factory(
"t",
vec![
Action::factory_add_col(ColumnDefinition::factory(
"c1",
DataType::integer(),
vec![ColumnConstraint::NotNullVariant],
)),
Action::factory_drop_col("c2"),
],
),
),
];
let parser = ApllodbSqlParser::default();
for (sql, expected_ast) in sql_vs_expected_ast {
match parser.parse(sql) {
Ok(ApllodbAst(Command::AlterTableCommandVariant(alter_table_command))) => {
assert_eq!(alter_table_command, expected_ast);
}
Ok(ast) => panic!(
"'{}' should be parsed as ALTER TABLE but is parsed like: {:?}",
sql, ast
),
Err(e) => panic!("{}", e),
}
}
}
#[test]
fn test_alter_table_rejected() {
let sqls: Vec<&str> = vec![
// Lack action.
"ALTER TABLE t",
// Lack data-type.
"ALTER TABLE t ADD COLUMN c1",
// Should not be parenthesized.
"ALTER TABLE t (ADD COLUMN c1 INTEGER)",
];
let parser = ApllodbSqlParser::default();
for sql in sqls {
assert!(parser.parse(sql).is_err());
}
}
|
use super::super::{
domain,
repository,
};
pub fn index(page: i32, page_size: i32) -> Vec<domain::user::DomainUser> {
let repository_user = repository::user::RepositoryUser::new();
let domain_users = repository_user.find_users(page, page_size);
domain_users
}
pub fn show(user_id: i32) -> domain::user::DomainUser {
let repository_user = repository::user::RepositoryUser::new();
let domain_user = repository_user.find_user(user_id);
domain_user
} |
// Copyright 2021 Contributors to the Parsec project.
// SPDX-License-Identifier: Apache-2.0
use cryptoki::context::{CInitializeArgs, Pkcs11};
use cryptoki::session::UserType;
use cryptoki::slot::Slot;
use std::env;
// The default user pin
pub static USER_PIN: &str = "fedcba";
// The default SO pin
pub static SO_PIN: &str = "abcdef";
pub fn init_pins() -> (Pkcs11, Slot) {
let mut pkcs11 = Pkcs11::new(
env::var("PKCS11_SOFTHSM2_MODULE")
.unwrap_or_else(|_| "/usr/local/lib/softhsm/libsofthsm2.so".to_string()),
)
.unwrap();
// initialize the library
pkcs11.initialize(CInitializeArgs::OsThreads).unwrap();
// find a slot, get the first one
let slot = pkcs11.get_slots_with_token().unwrap().remove(0);
pkcs11.init_token(slot, SO_PIN, "Test Token").unwrap();
{
// open a session
let session = pkcs11.open_rw_session(slot).unwrap();
// log in the session
session.login(UserType::So, Some(SO_PIN)).unwrap();
session.init_pin(USER_PIN).unwrap();
}
(pkcs11, slot)
}
|
use pyo3::{exceptions::PyValueError, prelude::*};
use serde::Deserialize;
#[derive(Deserialize)]
struct Data {
name: String,
value: u16,
}
#[pyfunction]
fn sum_json(input: &str) -> PyResult<u64> {
let d: Data = serde_json::from_str(input)
.map_err(|e| PyValueError::new_err(format!("{}", e)))?;
Ok(d.value as u64 + d.name.len() as u64)
}
#[pymodule]
fn json_summer(_py: Python, m: &PyModule) -> PyResult<()> {
m.add_function(wrap_pyfunction!(sum_json, m)?)?;
Ok(())
}
|
// MIPS has the following registers:
//
// | Symbolic Name | Number | Usage |
// | ============= | =============== | ============================== |
// | zero | 0 | Constant 0. |
// | at | 1 | Reserved for the assembler. |
// | v0 - v1 | 2 - 3 | Result Registers. |
// | a0 - a3 | 4 - 7 | Argument Registers 1 ·· · 4. |
// | t0 - t9 | 8 - 15, 24 - 25 | Temporary Registers 0 · · · 9. |
// | s0 - s7 | 16 - 23 | Saved Registers 0 ·· · 7. |
// | k0 - k1 | 26 - 27 | Kernel Registers 0 ·· · 1. |
// | gp | 28 | Global Data Pointer. |
// | sp | 29 | Stack Pointer. |
// | fp | 30 | Frame Pointer. |
// | ra | 31 | Return Address. |
//
// The following registers are used for args 1-6:
//
// arg1: %a0 ($4)
// arg2: %a1 ($5)
// arg3: %a2 ($6)
// arg4: %a3 ($7)
// arg5: (Passed via user stack)
// arg6: (Passed via user stack)
// arg7: (Passed via user stack)
//
// %v0 is the syscall number.
// %v0 is the return value.
// %a3 is a boolean indicating that an error occurred.
//
//
// All temporary registers are clobbered (8-15, 24-25).
use core::arch::asm;
use crate::arch::mips::Sysno;
/// Issues a raw system call with 0 arguments.
///
/// # Safety
///
/// Running a system call is inherently unsafe. It is the caller's
/// responsibility to ensure safety.
#[inline]
pub unsafe fn syscall0(n: Sysno) -> usize {
let mut err: usize;
let mut ret: usize;
asm!(
"syscall",
inlateout("$2") n as usize => ret,
lateout("$7") err,
// All temporary registers are always clobbered
lateout("$8") _,
lateout("$9") _,
lateout("$10") _,
lateout("$11") _,
lateout("$12") _,
lateout("$13") _,
lateout("$14") _,
lateout("$15") _,
lateout("$24") _,
lateout("$25") _,
options(nostack, preserves_flags)
);
if err == 0 {
ret
} else {
ret.wrapping_neg()
}
}
/// Issues a raw system call with 1 argument.
///
/// # Safety
///
/// Running a system call is inherently unsafe. It is the caller's
/// responsibility to ensure safety.
#[inline]
pub unsafe fn syscall1(n: Sysno, arg1: usize) -> usize {
let mut err: usize;
let mut ret: usize;
asm!(
"syscall",
inlateout("$2") n as usize => ret,
lateout("$7") err,
in("$4") arg1,
// All temporary registers are always clobbered
lateout("$8") _,
lateout("$9") _,
lateout("$10") _,
lateout("$11") _,
lateout("$12") _,
lateout("$13") _,
lateout("$14") _,
lateout("$15") _,
lateout("$24") _,
lateout("$25") _,
options(nostack, preserves_flags)
);
if err == 0 {
ret
} else {
ret.wrapping_neg()
}
}
/// Issues a raw system call with 2 arguments.
///
/// # Safety
///
/// Running a system call is inherently unsafe. It is the caller's
/// responsibility to ensure safety.
#[inline]
pub unsafe fn syscall2(n: Sysno, arg1: usize, arg2: usize) -> usize {
let mut err: usize;
let mut ret: usize;
asm!(
"syscall",
inlateout("$2") n as usize => ret,
lateout("$7") err,
in("$4") arg1,
in("$5") arg2,
// All temporary registers are always clobbered
lateout("$8") _,
lateout("$9") _,
lateout("$10") _,
lateout("$11") _,
lateout("$12") _,
lateout("$13") _,
lateout("$14") _,
lateout("$15") _,
lateout("$24") _,
lateout("$25") _,
options(nostack, preserves_flags)
);
if err == 0 {
ret
} else {
ret.wrapping_neg()
}
}
/// Issues a raw system call with 3 arguments.
///
/// # Safety
///
/// Running a system call is inherently unsafe. It is the caller's
/// responsibility to ensure safety.
#[inline]
pub unsafe fn syscall3(
n: Sysno,
arg1: usize,
arg2: usize,
arg3: usize,
) -> usize {
let mut err: usize;
let mut ret: usize;
asm!(
"syscall",
inlateout("$2") n as usize => ret,
lateout("$7") err,
in("$4") arg1,
in("$5") arg2,
in("$6") arg3,
// All temporary registers are always clobbered
lateout("$8") _,
lateout("$9") _,
lateout("$10") _,
lateout("$11") _,
lateout("$12") _,
lateout("$13") _,
lateout("$14") _,
lateout("$15") _,
lateout("$24") _,
lateout("$25") _,
options(nostack, preserves_flags)
);
if err == 0 {
ret
} else {
ret.wrapping_neg()
}
}
/// Issues a raw system call with 4 arguments.
///
/// # Safety
///
/// Running a system call is inherently unsafe. It is the caller's
/// responsibility to ensure safety.
#[inline]
pub unsafe fn syscall4(
n: Sysno,
arg1: usize,
arg2: usize,
arg3: usize,
arg4: usize,
) -> usize {
let mut err: usize;
let mut ret: usize;
asm!(
"syscall",
inlateout("$2") n as usize => ret,
in("$4") arg1,
in("$5") arg2,
in("$6") arg3,
// $7 is now used for both input and output.
inlateout("$7") arg4 => err,
// All temporary registers are always clobbered
lateout("$8") _,
lateout("$9") _,
lateout("$10") _,
lateout("$11") _,
lateout("$12") _,
lateout("$13") _,
lateout("$14") _,
lateout("$15") _,
lateout("$24") _,
lateout("$25") _,
options(nostack, preserves_flags)
);
if err == 0 {
ret
} else {
ret.wrapping_neg()
}
}
/// Issues a raw system call with 5 arguments.
///
/// # Safety
///
/// Running a system call is inherently unsafe. It is the caller's
/// responsibility to ensure safety.
#[inline]
pub unsafe fn syscall5(
n: Sysno,
arg1: usize,
arg2: usize,
arg3: usize,
arg4: usize,
arg5: usize,
) -> usize {
// NOTE: Arg numbers >=5 args get passed via the stack.
let mut err: usize;
let mut ret: usize;
asm!(
// NOTE: `.set noat` prevents the assembler from warning about using the
// `%at` (assembler temporary) register. This register could get
// allocated with `in(reg)` below.
".set noat",
"subu $sp, 32", // Make space on the stack.
"sw {arg5}, 16($sp)", // Store word arg5 in the stack.
"syscall",
"addu $sp, 32", // Restore the stack.
".set at",
arg5 = in(reg) arg5,
inlateout("$2") n as usize => ret,
in("$4") arg1,
in("$5") arg2,
in("$6") arg3,
// $7 is now used for both input and output.
inlateout("$7") arg4 => err,
// All temporary registers are always clobbered
lateout("$8") _,
lateout("$9") _,
lateout("$10") _,
lateout("$11") _,
lateout("$12") _,
lateout("$13") _,
lateout("$14") _,
lateout("$15") _,
lateout("$24") _,
lateout("$25") _,
options(preserves_flags)
);
if err == 0 {
ret
} else {
ret.wrapping_neg()
}
}
/// Issues a raw system call with 6 arguments.
///
/// # Safety
///
/// Running a system call is inherently unsafe. It is the caller's
/// responsibility to ensure safety.
#[inline]
pub unsafe fn syscall6(
n: Sysno,
arg1: usize,
arg2: usize,
arg3: usize,
arg4: usize,
arg5: usize,
arg6: usize,
) -> usize {
// Things get trickier with >=5 args. arg5 and arg6 are now passed via the
// stack.
let mut err: usize;
let mut ret: usize;
asm!(
// NOTE: `.set noat` prevents the assembler from warning about using the
// `%at` (assembler temporary) register. This register could get
// allocated with `in(reg)` below.
".set noat",
"subu $sp, 32", // Make space on the stack.
"sw {arg5}, 16($sp)", // Store word arg5 in the stack.
"sw {arg6}, 20($sp)", // Store word arg6 in the stack.
"syscall",
"addu $sp, 32", // Restore the stack.
".set at",
arg5 = in(reg) arg5,
arg6 = in(reg) arg6,
inlateout("$2") n as usize => ret,
in("$4") arg1,
in("$5") arg2,
in("$6") arg3,
// $7 is now used for both input and output.
inlateout("$7") arg4 => err,
// All temporary registers are always clobbered
lateout("$8") _,
lateout("$9") _,
lateout("$10") _,
lateout("$11") _,
lateout("$12") _,
lateout("$13") _,
lateout("$14") _,
lateout("$15") _,
lateout("$24") _,
lateout("$25") _,
options(preserves_flags)
);
if err == 0 {
ret
} else {
ret.wrapping_neg()
}
}
/// Issues a raw system call with 7 arguments.
///
/// # Safety
///
/// Running a system call is inherently unsafe. It is the caller's
/// responsibility to ensure safety.
#[allow(unused)]
#[inline]
pub unsafe fn syscall7(
n: Sysno,
arg1: usize,
arg2: usize,
arg3: usize,
arg4: usize,
arg5: usize,
arg6: usize,
arg7: usize,
) -> usize {
// Things get trickier with >=5 args. arg5 and arg6 are now passed via the
// stack.
let mut err: usize;
let mut ret: usize;
asm!(
// NOTE: `.set noat` prevents the assembler from warning about using the
// `%at` (assembler temporary) register. This register could get
// allocated with `in(reg)` below.
".set noat",
"subu $sp, 32", // Make space on the stack.
"sw {arg5}, 16($sp)", // Store word arg5 in the stack.
"sw {arg6}, 20($sp)", // Store word arg6 in the stack.
"sw {arg7}, 24($sp)", // Store word arg6 in the stack.
"syscall",
"addu $sp, 32", // Restore the stack.
".set at",
arg5 = in(reg) arg5,
arg6 = in(reg) arg6,
arg7 = in(reg) arg7,
inlateout("$2") n as usize => ret,
in("$4") arg1,
in("$5") arg2,
in("$6") arg3,
// $7 is now used for both input and output.
inlateout("$7") arg4 => err,
// All temporary registers are always clobbered
lateout("$8") _,
lateout("$9") _,
lateout("$10") _,
lateout("$11") _,
lateout("$12") _,
lateout("$13") _,
lateout("$14") _,
lateout("$15") _,
lateout("$24") _,
lateout("$25") _,
options(preserves_flags)
);
if err == 0 {
ret
} else {
ret.wrapping_neg()
}
}
|
#[doc = "Register `M1ISR` reader"]
pub type R = crate::R<M1ISR_SPEC>;
#[doc = "Field `SEDC` reader - ECC single error detected and corrected Note: This bit is reserved and must be kept at reset value in SRAM1 interrupt status register."]
pub type SEDC_R = crate::BitReader;
#[doc = "Field `DED` reader - ECC double error detected Note: This bit is reserved and must be kept at reset value in SRAM1 interrupt status register."]
pub type DED_R = crate::BitReader;
#[doc = "Field `SRAMBUSY` reader - SRAM busy with erase operation Note: Depending on the SRAM, the erase operation can be performed due to software request, system reset if the option bit is enabled, tamper detection or readout protection regression. Refer to Table 18: Internal SRAMs features."]
pub type SRAMBUSY_R = crate::BitReader;
impl R {
#[doc = "Bit 0 - ECC single error detected and corrected Note: This bit is reserved and must be kept at reset value in SRAM1 interrupt status register."]
#[inline(always)]
pub fn sedc(&self) -> SEDC_R {
SEDC_R::new((self.bits & 1) != 0)
}
#[doc = "Bit 1 - ECC double error detected Note: This bit is reserved and must be kept at reset value in SRAM1 interrupt status register."]
#[inline(always)]
pub fn ded(&self) -> DED_R {
DED_R::new(((self.bits >> 1) & 1) != 0)
}
#[doc = "Bit 8 - SRAM busy with erase operation Note: Depending on the SRAM, the erase operation can be performed due to software request, system reset if the option bit is enabled, tamper detection or readout protection regression. Refer to Table 18: Internal SRAMs features."]
#[inline(always)]
pub fn srambusy(&self) -> SRAMBUSY_R {
SRAMBUSY_R::new(((self.bits >> 8) & 1) != 0)
}
}
#[doc = "RAMCFG memory interrupt status register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`m1isr::R`](R). See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct M1ISR_SPEC;
impl crate::RegisterSpec for M1ISR_SPEC {
type Ux = u32;
}
#[doc = "`read()` method returns [`m1isr::R`](R) reader structure"]
impl crate::Readable for M1ISR_SPEC {}
#[doc = "`reset()` method sets M1ISR to value 0"]
impl crate::Resettable for M1ISR_SPEC {
const RESET_VALUE: Self::Ux = 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.